编译器
0.8.18+commit.87f61d96
文件 1 的 27:Address.sol
pragma solidity ^0.8.1;
library Address {
function isContract(address account) internal view returns (bool) {
return account.code.length > 0;
}
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");
}
function functionCall(address target, bytes memory data) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, "Address: low-level call failed");
}
function functionCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
return functionCallWithValue(target, data, 0, errorMessage);
}
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");
}
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");
(bool success, bytes memory returndata) = target.call{value: value}(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
return functionStaticCall(target, data, "Address: low-level static call failed");
}
function functionStaticCall(
address target,
bytes memory data,
string memory errorMessage
) internal view returns (bytes memory) {
(bool success, bytes memory returndata) = target.staticcall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
return functionDelegateCall(target, data, "Address: low-level delegate call failed");
}
function functionDelegateCall(
address target,
bytes memory data,
string memory errorMessage
) internal returns (bytes memory) {
(bool success, bytes memory returndata) = target.delegatecall(data);
return verifyCallResultFromTarget(target, success, returndata, errorMessage);
}
function verifyCallResultFromTarget(
address target,
bool success,
bytes memory returndata,
string memory errorMessage
) internal view returns (bytes memory) {
if (success) {
if (returndata.length == 0) {
require(isContract(target), "Address: call to non-contract");
}
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function verifyCallResult(
bool success,
bytes memory returndata,
string memory errorMessage
) internal pure returns (bytes memory) {
if (success) {
return returndata;
} else {
_revert(returndata, errorMessage);
}
}
function _revert(bytes memory returndata, string memory errorMessage) private pure {
if (returndata.length > 0) {
assembly {
let returndata_size := mload(returndata)
revert(add(32, returndata), returndata_size)
}
} else {
revert(errorMessage);
}
}
}
文件 2 的 27:ArbUtils.sol
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IERC20.sol";
pragma solidity ^0.8.15;
library ArbUtils {
function calculateArbitrage(address _weth, address usdcP, address wethP, address token, uint256 quote, uint256 uptwp, uint256 wptwp) internal view returns (uint256 amount, bool isUsdcLower) {
{
int256 a1;
int256 b1;
int256 a2;
int256 b2;
if(uptwp < wptwp) {
a1 = (int256) (quote);
b1 = (int256) (IERC20(token).balanceOf(usdcP));
a2 = (int256) (IERC20(_weth).balanceOf(wethP));
b2 = (int256) (IERC20(token).balanceOf(wethP));
isUsdcLower = true;
} else {
a2 = (int256) (quote);
b2 = (int256) (IERC20(token).balanceOf(usdcP));
a1 = (int256) (IERC20(_weth).balanceOf(wethP));
b1 = (int256) (IERC20(token).balanceOf(wethP));
isUsdcLower = false;
}
int256 a = (a1 * b1 - a2 * b2)/(10**27);
int256 b = (2 * b1 * b2 * (a1 + a2))/(10**27);
int256 c = (b1 * b2 * (a1 * b2 - a2 * b1))/(10**27);
(int256 x1,) = calcSolutionForQuadratic(a, b, c);
amount = uint256(x1) * 2;
}
}
function calcSolutionForQuadratic(
int256 a,
int256 b,
int256 c
) public pure returns (int256 x1, int256 x2) {
int256 m = b**2 - 4 * a * c;
require(m > 0, 'ArbUtils: COMPLEX');
int256 sqrtM = int256(sqrt(uint256(m)));
x1 = (-b + sqrtM) / (2 * a);
x2 = (-b - sqrtM) / (2 * a);
}
function sqrt(uint256 n) internal pure returns (uint256 res) {
assert(n > 1);
uint256 _n = n * 10**6;
uint256 c = _n;
res = _n;
uint256 xi;
while (true) {
xi = (res + c / res) / 2;
if (res - xi < 1000) {
break;
}
res = xi;
}
res = res / 10**3;
}
}
文件 3 的 27:Context.sol
pragma solidity ^0.8.0;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
文件 4 的 27:Counters.sol
pragma solidity ^0.8.0;
library Counters {
struct Counter {
uint256 _value;
}
function current(Counter storage counter) internal view returns (uint256) {
return counter._value;
}
function increment(Counter storage counter) internal {
unchecked {
counter._value += 1;
}
}
function decrement(Counter storage counter) internal {
uint256 value = counter._value;
require(value > 0, "Counter: decrement overflow");
unchecked {
counter._value = value - 1;
}
}
function reset(Counter storage counter) internal {
counter._value = 0;
}
}
文件 5 的 27:DividendPayingToken.sol
pragma solidity ^0.8.15;
import "@uniswap/v2-core/contracts/interfaces/IERC20.sol";
import "./DividendPayingTokenInterface.sol";
import "./DividendPayingTokenOptionalInterface.sol";
import "./math/SafeMathUint.sol";
import "./math/SafeMathInt.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
abstract contract DividendPayingToken is
Ownable,
DividendPayingTokenInterface,
DividendPayingTokenOptionalInterface
{
using SafeMath for uint256;
using SafeMathUint for uint256;
using SafeMathInt for int256;
address public REWARD_TOKEN;
address public stakingImpl;
uint256 internal constant magnitude = 2 ** 128;
uint256 internal magnifiedDividendPerShare;
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_totalSupply += amount;
_balances[account] += amount;
magnifiedDividendCorrections[account] = magnifiedDividendCorrections[
account
].sub((magnifiedDividendPerShare.mul(amount)).toInt256Safe());
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
}
_totalSupply -= amount;
magnifiedDividendCorrections[account] = magnifiedDividendCorrections[
account
].add((magnifiedDividendPerShare.mul(amount)).toInt256Safe());
}
modifier onlySSHex() {
require(_msgSender() == owner() || _msgSender() == stakingImpl, "Only senders.");
_;
}
mapping(address => int256) internal magnifiedDividendCorrections;
mapping(address => uint256) internal withdrawnDividends;
uint256 public totalDividendsDistributed;
constructor(
address _rewardTokenAddress
) {
REWARD_TOKEN = _rewardTokenAddress;
}
function setStakingImpl(address impl) public onlyOwner {
stakingImpl = impl;
}
function afterReceivedHex(uint256 amount) public onlySSHex {
if (_totalSupply > 0 && amount > 0) {
magnifiedDividendPerShare = magnifiedDividendPerShare.add(
(amount).mul(magnitude) / _totalSupply
);
emit DividendsDistributed(msg.sender, amount);
totalDividendsDistributed = totalDividendsDistributed.add(amount);
}
}
function withdrawDividend() public virtual override {
_withdrawDividendOfUser(payable(msg.sender));
}
function _withdrawDividendOfUser(
address payable user
) internal returns (uint256) {
uint256 _withdrawableDividend = withdrawableDividendOf(user);
if (_withdrawableDividend > 0) {
withdrawnDividends[user] = withdrawnDividends[user].add(
_withdrawableDividend
);
emit DividendWithdrawn(user, _withdrawableDividend);
bool success = IERC20(REWARD_TOKEN).transfer(
user,
_withdrawableDividend
);
if (!success) {
withdrawnDividends[user] = withdrawnDividends[user].sub(
_withdrawableDividend
);
return 0;
}
return _withdrawableDividend;
}
return 0;
}
function dividendOf(address _owner) public view override returns (uint256) {
return withdrawableDividendOf(_owner);
}
function withdrawableDividendOf(
address _owner
) public view override returns (uint256) {
return accumulativeDividendOf(_owner).sub(withdrawnDividends[_owner]);
}
function withdrawnDividendOf(
address _owner
) public view override returns (uint256) {
return withdrawnDividends[_owner];
}
function accumulativeDividendOf(
address _owner
) public view override returns (uint256) {
return
magnifiedDividendPerShare
.mul(_balances[_owner])
.toInt256Safe()
.add(magnifiedDividendCorrections[_owner])
.toUint256Safe() / magnitude;
}
function _transfer(
address from,
address to,
uint256 value
) internal virtual {
require(false);
int256 _magCorrection = magnifiedDividendPerShare
.mul(value)
.toInt256Safe();
magnifiedDividendCorrections[from] = magnifiedDividendCorrections[from]
.add(_magCorrection);
magnifiedDividendCorrections[to] = magnifiedDividendCorrections[to].sub(
_magCorrection
);
}
function _setBalance(address account, uint256 newBalance) internal {
uint256 currentBalance = _balances[account];
if (newBalance > currentBalance) {
uint256 mintAmount = newBalance.sub(currentBalance);
_mint(account, mintAmount);
} else if (newBalance < currentBalance) {
uint256 burnAmount = currentBalance.sub(newBalance);
_burn(account, burnAmount);
}
}
}
文件 6 的 27:DividendPayingTokenInterface.sol
pragma solidity ^0.8.15;
interface DividendPayingTokenInterface {
function dividendOf(address _owner) external view returns(uint256);
function distributeDividends() external payable;
function withdrawDividend() external;
event DividendsDistributed(
address indexed from,
uint256 weiAmount
);
event DividendWithdrawn(
address indexed to,
uint256 weiAmount
);
}
文件 7 的 27:DividendPayingTokenOptionalInterface.sol
pragma solidity ^0.8.15;
interface DividendPayingTokenOptionalInterface {
function withdrawableDividendOf(address _owner) external view returns(uint256);
function withdrawnDividendOf(address _owner) external view returns(uint256);
function accumulativeDividendOf(address _owner) external view returns(uint256);
}
文件 8 的 27:ECDSA.sol
pragma solidity ^0.8.0;
import "../Strings.sol";
library ECDSA {
enum RecoverError {
NoError,
InvalidSignature,
InvalidSignatureLength,
InvalidSignatureS,
InvalidSignatureV
}
function _throwError(RecoverError error) private pure {
if (error == RecoverError.NoError) {
return;
} else if (error == RecoverError.InvalidSignature) {
revert("ECDSA: invalid signature");
} else if (error == RecoverError.InvalidSignatureLength) {
revert("ECDSA: invalid signature length");
} else if (error == RecoverError.InvalidSignatureS) {
revert("ECDSA: invalid signature 's' value");
}
}
function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
if (signature.length == 65) {
bytes32 r;
bytes32 s;
uint8 v;
assembly {
r := mload(add(signature, 0x20))
s := mload(add(signature, 0x40))
v := byte(0, mload(add(signature, 0x60)))
}
return tryRecover(hash, v, r, s);
} else {
return (address(0), RecoverError.InvalidSignatureLength);
}
}
function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, signature);
_throwError(error);
return recovered;
}
function tryRecover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address, RecoverError) {
bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
uint8 v = uint8((uint256(vs) >> 255) + 27);
return tryRecover(hash, v, r, s);
}
function recover(
bytes32 hash,
bytes32 r,
bytes32 vs
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, r, vs);
_throwError(error);
return recovered;
}
function tryRecover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address, RecoverError) {
if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
return (address(0), RecoverError.InvalidSignatureS);
}
address signer = ecrecover(hash, v, r, s);
if (signer == address(0)) {
return (address(0), RecoverError.InvalidSignature);
}
return (signer, RecoverError.NoError);
}
function recover(
bytes32 hash,
uint8 v,
bytes32 r,
bytes32 s
) internal pure returns (address) {
(address recovered, RecoverError error) = tryRecover(hash, v, r, s);
_throwError(error);
return recovered;
}
function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
}
function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
}
function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
}
}
文件 9 的 27:IERC20.sol
pragma solidity >=0.5.0;
interface IERC20 {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint 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 (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint value) external returns (bool);
}
文件 10 的 27:IHex.sol
pragma solidity ^0.8.15;
interface IHex {
event StakeStart(
uint256 data0,
address indexed stakerAddr,
uint40 indexed stakeId
);
event StakeGoodAccounting(
uint256 data0,
uint256 data1,
address indexed stakerAddr,
uint40 indexed stakeId,
address indexed senderAddr
);
event StakeEnd(
uint256 data0,
uint256 data1,
address indexed stakerAddr,
uint40 indexed stakeId
);
function balanceOf(address account) external view returns (uint256);
function transfer(address recipient, uint256 amount) external returns (bool);
function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);
function stakeLists(address, uint256) view external returns(uint40 stakeId, uint72 stakedHearts, uint72 stakeShares, uint16 lockedDay, uint16 stakedDays, uint16 unlockedDay, bool isAutoStake);
function dailyDataUpdate(uint256 beforeDay) external;
function dailyDataRange(uint256 beginDay, uint256 endDay) external view returns (uint256[] memory list);
function globalInfo() external view returns (uint256[13] memory);
function currentDay() external view returns (uint256);
function stakeStart(uint256 newStakedHearts, uint256 newStakedDays) external;
function stakeGoodAccounting(address stakerAddr, uint256 stakeIndex, uint40 stakeIdParam) external;
function stakeEnd(uint256 stakeIndex, uint40 stakeIdParam) external;
function stakeCount(address stakerAddr) external view returns (uint256);
}
文件 11 的 27:IMultisend.sol
pragma solidity ^0.8.15;
interface IMultisend {
function multisend(address[] calldata addr, uint256[] calldata val) external;
function multisendFrom(address sender, address[] calldata addrRecipients, uint256[] calldata vals) external;
}
文件 12 的 27:IUniswapV2Factory.sol
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;
}
文件 13 的 27:IUniswapV2Pair.sol
pragma solidity >=0.5.0;
interface IUniswapV2Pair {
event Approval(address indexed owner, address indexed spender, uint value);
event Transfer(address indexed from, address indexed to, uint 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 (uint);
function balanceOf(address owner) external view returns (uint);
function allowance(address owner, address spender) external view returns (uint);
function approve(address spender, uint value) external returns (bool);
function transfer(address to, uint value) external returns (bool);
function transferFrom(address from, address to, uint 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 (uint);
function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;
event Mint(address indexed sender, uint amount0, uint amount1);
event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
event Swap(
address indexed sender,
uint amount0In,
uint amount1In,
uint amount0Out,
uint amount1Out,
address indexed to
);
event Sync(uint112 reserve0, uint112 reserve1);
function MINIMUM_LIQUIDITY() external pure returns (uint);
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 (uint);
function price1CumulativeLast() external view returns (uint);
function kLast() external view returns (uint);
function mint(address to) external returns (uint liquidity);
function burn(address to) external returns (uint amount0, uint amount1);
function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
function skim(address to) external;
function sync() external;
function initialize(address, address) external;
}
文件 14 的 27:IUniswapV2Router01.sol
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);
}
文件 15 的 27:IUniswapV2Router02.sol
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;
}
文件 16 的 27:IUniswapV3PoolImmutables.sol
pragma solidity >=0.5.0;
interface IUniswapV3PoolImmutables {
function factory() external view returns (address);
function token0() external view returns (address);
function token1() external view returns (address);
function fee() external view returns (uint24);
function tickSpacing() external view returns (int24);
function maxLiquidityPerTick() external view returns (uint128);
}
文件 17 的 27:IWETH.sol
pragma solidity >=0.5.0;
interface IWETH {
function deposit() external payable;
function transfer(address to, uint value) external returns (bool);
function withdraw(uint) external;
}
文件 18 的 27:Math.sol
pragma solidity ^0.8.0;
library Math {
enum Rounding {
Down,
Up,
Zero
}
function max(uint256 a, uint256 b) internal pure returns (uint256) {
return a > b ? a : b;
}
function min(uint256 a, uint256 b) internal pure returns (uint256) {
return a < b ? a : b;
}
function average(uint256 a, uint256 b) internal pure returns (uint256) {
return (a & b) + (a ^ b) / 2;
}
function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
return a == 0 ? 0 : (a - 1) / b + 1;
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator
) internal pure returns (uint256 result) {
unchecked {
uint256 prod0;
uint256 prod1;
assembly {
let mm := mulmod(x, y, not(0))
prod0 := mul(x, y)
prod1 := sub(sub(mm, prod0), lt(mm, prod0))
}
if (prod1 == 0) {
return prod0 / denominator;
}
require(denominator > prod1);
uint256 remainder;
assembly {
remainder := mulmod(x, y, denominator)
prod1 := sub(prod1, gt(remainder, prod0))
prod0 := sub(prod0, remainder)
}
uint256 twos = denominator & (~denominator + 1);
assembly {
denominator := div(denominator, twos)
prod0 := div(prod0, twos)
twos := add(div(sub(0, twos), twos), 1)
}
prod0 |= prod1 * twos;
uint256 inverse = (3 * denominator) ^ 2;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
inverse *= 2 - denominator * inverse;
result = prod0 * inverse;
return result;
}
}
function mulDiv(
uint256 x,
uint256 y,
uint256 denominator,
Rounding rounding
) internal pure returns (uint256) {
uint256 result = mulDiv(x, y, denominator);
if (rounding == Rounding.Up && mulmod(x, y, denominator) > 0) {
result += 1;
}
return result;
}
function sqrt(uint256 a) internal pure returns (uint256) {
if (a == 0) {
return 0;
}
uint256 result = 1 << (log2(a) >> 1);
unchecked {
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
result = (result + a / result) >> 1;
return min(result, a / result);
}
}
function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = sqrt(a);
return result + (rounding == Rounding.Up && result * result < a ? 1 : 0);
}
}
function log2(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 128;
}
if (value >> 64 > 0) {
value >>= 64;
result += 64;
}
if (value >> 32 > 0) {
value >>= 32;
result += 32;
}
if (value >> 16 > 0) {
value >>= 16;
result += 16;
}
if (value >> 8 > 0) {
value >>= 8;
result += 8;
}
if (value >> 4 > 0) {
value >>= 4;
result += 4;
}
if (value >> 2 > 0) {
value >>= 2;
result += 2;
}
if (value >> 1 > 0) {
result += 1;
}
}
return result;
}
function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log2(value);
return result + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
}
}
function log10(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >= 10**64) {
value /= 10**64;
result += 64;
}
if (value >= 10**32) {
value /= 10**32;
result += 32;
}
if (value >= 10**16) {
value /= 10**16;
result += 16;
}
if (value >= 10**8) {
value /= 10**8;
result += 8;
}
if (value >= 10**4) {
value /= 10**4;
result += 4;
}
if (value >= 10**2) {
value /= 10**2;
result += 2;
}
if (value >= 10**1) {
result += 1;
}
}
return result;
}
function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log10(value);
return result + (rounding == Rounding.Up && 10**result < value ? 1 : 0);
}
}
function log256(uint256 value) internal pure returns (uint256) {
uint256 result = 0;
unchecked {
if (value >> 128 > 0) {
value >>= 128;
result += 16;
}
if (value >> 64 > 0) {
value >>= 64;
result += 8;
}
if (value >> 32 > 0) {
value >>= 32;
result += 4;
}
if (value >> 16 > 0) {
value >>= 16;
result += 2;
}
if (value >> 8 > 0) {
result += 1;
}
}
return result;
}
function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
unchecked {
uint256 result = log256(value);
return result + (rounding == Rounding.Up && 1 << (result * 8) < value ? 1 : 0);
}
}
}
文件 19 的 27:Ownable.sol
pragma solidity ^0.8.0;
import "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor() {
_transferOwnership(_msgSender());
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
require(owner() == _msgSender(), "Ownable: caller is not the owner");
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
require(newOwner != address(0), "Ownable: new owner is the zero address");
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 20 的 27:SafeMath.sol
pragma solidity ^0.8.0;
library SafeMath {
function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
uint256 c = a + b;
if (c < a) return (false, 0);
return (true, c);
}
}
function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b > a) return (false, 0);
return (true, a - b);
}
}
function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (a == 0) return (true, 0);
uint256 c = a * b;
if (c / a != b) return (false, 0);
return (true, c);
}
}
function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a / b);
}
}
function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
unchecked {
if (b == 0) return (false, 0);
return (true, a % b);
}
}
function add(uint256 a, uint256 b) internal pure returns (uint256) {
return a + b;
}
function sub(uint256 a, uint256 b) internal pure returns (uint256) {
return a - b;
}
function mul(uint256 a, uint256 b) internal pure returns (uint256) {
return a * b;
}
function div(uint256 a, uint256 b) internal pure returns (uint256) {
return a / b;
}
function mod(uint256 a, uint256 b) internal pure returns (uint256) {
return a % b;
}
function sub(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b <= a, errorMessage);
return a - b;
}
}
function div(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a / b;
}
}
function mod(
uint256 a,
uint256 b,
string memory errorMessage
) internal pure returns (uint256) {
unchecked {
require(b > 0, errorMessage);
return a % b;
}
}
}
文件 21 的 27:SafeMathInt.sol
pragma solidity ^0.8.15;
library SafeMathInt {
function mul(int256 a, int256 b) internal pure returns (int256) {
require(!(a == - 2**255 && b == -1) && !(b == - 2**255 && a == -1));
int256 c = a * b;
require((b == 0) || (c / b == a));
return c;
}
function div(int256 a, int256 b) internal pure returns (int256) {
require(!(a == - 2**255 && b == -1) && (b > 0));
return a / b;
}
function sub(int256 a, int256 b) internal pure returns (int256) {
require((b >= 0 && a - b <= a) || (b < 0 && a - b > a));
return a - b;
}
function add(int256 a, int256 b) internal pure returns (int256) {
int256 c = a + b;
require((b >= 0 && c >= a) || (b < 0 && c < a));
return c;
}
function toUint256Safe(int256 a) internal pure returns (uint256) {
require(a >= 0);
return uint256(a);
}
}
文件 22 的 27:SafeMathUint.sol
pragma solidity ^0.8.15;
library SafeMathUint {
function toInt256Safe(uint256 a) internal pure returns (int256) {
int256 b = int256(a);
require(b >= 0);
return b;
}
}
文件 23 的 27:SimpleStaking.sol
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/utils/Address.sol";
import "@openzeppelin/contracts/utils/Context.sol";
import "@uniswap/v2-core/contracts/interfaces/IERC20.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IWETH.sol";
import "@uniswap/v3-core/contracts/interfaces/pool/IUniswapV3PoolImmutables.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";
import "@openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol";
import "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import "@openzeppelin/contracts/utils/Counters.sol";
import "./DPT/TokenDividendTracker.sol";
import "./SimpleStakingImpl.sol";
import "./IMultisend.sol";
import "./ArbUtils.sol";
contract SuperStake is Context, IERC20, Ownable, IERC20Permit, IMultisend {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
bytes32 private immutable _CACHED_DOMAIN_SEPARATOR;
uint256 private immutable _CACHED_CHAIN_ID;
address private immutable _CACHED_THIS;
bytes32 private immutable _HASHED_NAME;
bytes32 private immutable _HASHED_VERSION;
bytes32 private immutable _TYPE_HASH;
event ArbitragedPools(uint256 amount, bool wasUsdcLower);
event Bought(address indexed buyer, uint256 amount);
event Sold(address indexed seller, uint256 amount);
event Minted(uint256 amount);
event Burned(uint256 amount);
using SafeMath for uint256;
string private constant _name = "SuperStake: Hex";
string private constant _symbol = "SSH";
string private constant _max = "SSH: MAX";
string private constant _reinit = "SSH: REINIT";
uint8 private constant _decimals = 9;
uint256 private constant initialSupply = 55550000 * 10**9;
uint256 public currentSupply;
address private _usdc = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
address private constant _dead = 0x000000000000000000000000000000000000dEaD;
address private _wnative;
mapping(address => uint256) private tokensOwned;
mapping(address => mapping(address => uint256)) private _allowances;
struct mappingStructs {
bool _isExcludedFromFee;
bool _bots;
uint32 _lastTxBuy;
uint32 _lastTxSell;
uint32 botBlock;
bool isLPPair;
bool isInitialLP;
}
struct LaggedLPData {
address lpAddr;
uint112 reserve0;
uint112 reserve1;
uint256 laggedBurnAmt;
}
mapping(address => mappingStructs) private mappedAddresses;
mapping(address => uint256) private airdropTokens;
address[] private airdropPrivateList;
address[] private lpPairs;
address[] private initialLPPairs;
uint256 private laggedBurnAmt;
LaggedLPData private laggedLP;
uint256 public currentChainId;
address public dividendTracker;
uint32 private gasForProcessing = 300000;
uint32 private hexStakingRatio = 2500;
bool private disableAddToBlocklist = false;
bool private removedLimits = false;
uint32 private openBlock;
uint32 private pair1Pct = 50;
address public stakingImpl;
uint32 private hexRewardRatio = 5000;
address private rewardToken = 0x2b591e99afE9f32eAA6214f7B7629768c40Eeb39;
uint32 private pair2Pct = 50;
uint32 private buyInfl = 7500;
uint32 private sellDefl = 9000;
bool private tradingOpen;
bool private inSwap = false;
bool private swapEnabled = false;
bool private arbEnabled = true;
IUniswapV2Router02 private uniswapV2Router;
constructor(address router) {
uniswapV2Router = IUniswapV2Router02(router);
bytes32 hashedName = keccak256(bytes(_name));
bytes32 hashedVersion = keccak256(bytes("1"));
bytes32 typeHash = keccak256(
"EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"
);
_HASHED_NAME = hashedName;
_HASHED_VERSION = hashedVersion;
_CACHED_CHAIN_ID = block.chainid;
_CACHED_DOMAIN_SEPARATOR = _buildDomainSeparator(typeHash, hashedName, hashedVersion);
_CACHED_THIS = address(this);
_TYPE_HASH = typeHash;
tokensOwned[_msgSender()] = initialSupply;
currentSupply = initialSupply;
TokenDividendTracker tracker = new TokenDividendTracker(rewardToken, 1000000000);
dividendTracker = address(tracker);
SimpleStakingImpl staker = new SimpleStakingImpl(rewardToken, 60, dividendTracker, address(0x3819f64f282bf135d62168C1e513280dAF905e06), router);
stakingImpl = address(staker);
tracker.setStakingImpl(stakingImpl);
tracker.excludeFromDividends(dividendTracker);
tracker.excludeFromDividends(address(this));
tracker.excludeFromDividends(owner());
tracker.excludeFromDividends(_dead);
currentChainId = block.chainid;
mappedAddresses[_msgSender()] = mappingStructs({
_isExcludedFromFee: true,
_bots: false,
_lastTxBuy: 0,
_lastTxSell: 0,
botBlock: 0,
isLPPair: false,
isInitialLP: false
});
mappedAddresses[address(this)] = mappingStructs({
_isExcludedFromFee: true,
_bots: false,
_lastTxBuy: 0,
_lastTxSell: 0,
botBlock: 0,
isLPPair: false,
isInitialLP: false
});
mappedAddresses[dividendTracker] = mappingStructs({
_isExcludedFromFee: true,
_bots: false,
_lastTxBuy: 0,
_lastTxSell: 0,
botBlock: 0,
isLPPair: false,
isInitialLP: false
});
emit Transfer(address(0), _msgSender(), initialSupply);
}
function name() public pure returns (string memory) {
return _name;
}
function symbol() public pure returns (string memory) {
return _symbol;
}
function decimals() public pure returns (uint8) {
return _decimals;
}
function totalSupply() public view override returns (uint256) {
return currentSupply;
}
function balanceOf(address account) public view override returns (uint256) {
return tokensOwned[account];
}
function _increaseSupply(uint256 amt) internal {
currentSupply += amt;
tokensOwned[address(this)] += amt;
emit Transfer(address(0), address(this), amt);
emit Minted(amt);
}
function _decreaseSupply(uint256 amt, address lpToBurn) internal {
currentSupply -= amt;
tokensOwned[lpToBurn] -= amt;
IUniswapV2Pair(lpToBurn).sync();
emit Transfer(lpToBurn, address(0), amt);
emit Burned(amt);
}
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()].sub(
amount,
"ERC20: transfer amount exceeds allowance"
)
);
return true;
}
function openTrading(address nativeWrapped) public onlyOwner {
require(!tradingOpen, "OPEN");
_wnative = nativeWrapped;
TokenDividendTracker(dividendTracker).excludeFromDividends(address(uniswapV2Router));
_approve(address(this), address(uniswapV2Router), type(uint256).max);
address uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory())
.createPair(address(this), _wnative);
address uniswapV2Pair2 = IUniswapV2Factory(uniswapV2Router.factory())
.createPair(
address(this),
_usdc
);
TokenDividendTracker(dividendTracker).excludeFromDividends(address(uniswapV2Pair));
TokenDividendTracker(dividendTracker).excludeFromDividends(address(uniswapV2Pair2));
uint256 pair1TAmt = (balanceOf(address(this)) * pair1Pct) / 100;
uint256 pair2TAmt = (balanceOf(address(this)) * pair2Pct) / 100;
uint256 pair1EAmt = (address(this).balance);
uniswapV2Router.addLiquidityETH{value: pair1EAmt}(
address(this),
pair1TAmt,
0,
0,
owner(),
block.timestamp
);
IERC20 usdc = IERC20(_usdc);
uint256 pair2UAmt = usdc.balanceOf(address(this));
usdc.approve(address(uniswapV2Router), pair2UAmt);
uniswapV2Router.addLiquidity(
_usdc,
address(this),
pair2UAmt,
pair2TAmt,
0,
0,
owner(),
block.timestamp
);
swapEnabled = true;
tradingOpen = true;
openBlock = uint32(block.number);
IERC20(uniswapV2Pair).approve(
address(uniswapV2Router),
type(uint256).max
);
IERC20(uniswapV2Pair2).approve(
address(uniswapV2Router),
type(uint256).max
);
mappedAddresses[uniswapV2Pair] = mappingStructs({
_isExcludedFromFee: false,
_bots: false,
_lastTxBuy: 0,
_lastTxSell: 0,
botBlock: 0,
isLPPair: true,
isInitialLP: true
});
mappedAddresses[uniswapV2Pair2] = mappingStructs({
_isExcludedFromFee: false,
_bots: false,
_lastTxBuy: 0,
_lastTxSell: 0,
botBlock: 0,
isLPPair: true,
isInitialLP: true
});
lpPairs.push(uniswapV2Pair);
lpPairs.push(uniswapV2Pair2);
initialLPPairs.push(uniswapV2Pair);
initialLPPairs.push(uniswapV2Pair2);
}
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");
uint32 _flAmt;
bool isSell = false;
if (
from != owner() &&
to != owner() &&
from != address(this) &&
!mappedAddresses[to]._isExcludedFromFee &&
!mappedAddresses[from]._isExcludedFromFee
) {
require(
!mappedAddresses[to]._bots && !mappedAddresses[from]._bots,
"SSH: Blocklisted."
);
if (mappedAddresses[from].isLPPair) {
IUniswapV2Pair lpPair = IUniswapV2Pair(from);
if(lpPair.token0() == address(this)) {
IERC20 otherTok = IERC20(lpPair.token1());
(, uint112 reserve1,) = lpPair.getReserves();
if(otherTok.balanceOf(from) > reserve1) {
_flAmt = buyInfl;
require(mappedAddresses[to]._lastTxSell != uint32(block.number), "SSH: SWCH");
mappedAddresses[to]._lastTxBuy = uint32(block.number);
} else {
_flAmt = 0;
}
} else {
IERC20 otherTok = IERC20(lpPair.token0());
(uint112 reserve0, ,) = lpPair.getReserves();
if(otherTok.balanceOf(from) > reserve0) {
_flAmt = buyInfl;
require(mappedAddresses[to]._lastTxSell != uint32(block.number), "SSH: SWCH");
mappedAddresses[to]._lastTxBuy = uint32(block.number);
} else {
_flAmt = 0;
}
}
} else if (mappedAddresses[to].isLPPair) {
isSell = true;
_flAmt = sellDefl;
require(mappedAddresses[from]._lastTxBuy != uint32(block.number), "SSH: SWCH");
mappedAddresses[from]._lastTxSell = uint32(block.number);
} else {
_flAmt = 0;
uint8 lpType = isNewLP(to);
require(lpType != 2, "SSH: No v3 LP.");
if(lpType == 1) {
mappedAddresses[to].isLPPair = true;
lpPairs.push(to);
TokenDividendTracker(dividendTracker).excludeFromDividends(to);
} else {
}
}
} else {
_flAmt = 0;
}
_tokenTransfer(from, to, amount, _flAmt, isSell);
}
function doTaxes(uint256 tokenAmount, bool useEthPair) private {
inSwap = true;
if(_allowances[address(this)][address(uniswapV2Router)] < tokenAmount) {
_approve(address(this), address(uniswapV2Router), type(uint256).max);
}
uint256 sellAmt = tokenAmount;
if (useEthPair) {
address[] memory path = new address[](3);
path[0] = address(this);
path[1] = _wnative;
path[2] = rewardToken;
uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
sellAmt,
0,
path,
address(this),
block.timestamp
);
} else {
address[] memory path = new address[](4);
path[0] = address(this);
path[1] = _usdc;
path[2] = _wnative;
path[3] = rewardToken;
uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
sellAmt,
0,
path,
address(this),
block.timestamp
);
}
uint64 divisor = hexRewardRatio + hexStakingRatio;
IERC20 hexToken = IERC20(rewardToken);
uint256 hexAmount = hexToken.balanceOf(address(this));
hexToken.transfer(stakingImpl, (hexAmount * hexStakingRatio) / divisor);
SimpleStakingImpl(stakingImpl).afterReceivedHex();
hexToken.transfer(dividendTracker, (hexAmount * hexRewardRatio) / divisor);
TokenDividendTracker(dividendTracker).afterReceivedHex((hexAmount * hexRewardRatio) / divisor);
inSwap = false;
}
receive() external payable {}
function setArbEnabled(bool enabled) external onlyOwner {
arbEnabled = enabled;
}
function doLaggedBurn(bool isSell, address sender) internal {
if(laggedBurnAmt > 0) {
{
IUniswapV2Pair lpPair = IUniswapV2Pair(laggedLP.lpAddr);
(uint112 reserve0, uint112 reserve1,) = lpPair.getReserves();
if(laggedLP.reserve0 < reserve0 && laggedLP.reserve1 < reserve1) {
if(laggedBurnAmt <= laggedLP.laggedBurnAmt) {
laggedBurnAmt = 0;
} else {
laggedBurnAmt -= laggedLP.laggedBurnAmt;
}
delete(laggedLP);
return;
}
}
if(isSell) {
uint8 best = 0;
uint256 lastBal;
for(uint8 i = 0; i < lpPairs.length; i++) {
if(lpPairs[i] != sender && tokensOwned[(lpPairs[i])] > 0) {
if(lastBal == 0) {
lastBal = tokensOwned[(lpPairs[i])];
best = i;
} else {
if(lastBal < tokensOwned[lpPairs[i]]) {
best = i;
lastBal = tokensOwned[lpPairs[i]];
}
}
}
}
delete(laggedLP);
if(lastBal < laggedBurnAmt) {
return;
} else {
_decreaseSupply(laggedBurnAmt, lpPairs[best]);
laggedBurnAmt = 0;
}
} else {
uint8 best = 0;
uint256 lastBal;
for(uint8 i = 0; i < lpPairs.length; i++) {
if(lpPairs[i] != sender && tokensOwned[(lpPairs[i])] > 0) {
if(lastBal == 0) {
best = i;
lastBal = tokensOwned[lpPairs[i]];
} else {
if(lastBal < tokensOwned[lpPairs[i]]) {
best = i;
lastBal = tokensOwned[lpPairs[i]];
}
}
}
}
delete(laggedLP);
if(tokensOwned[lpPairs[best]] < laggedBurnAmt) {
return;
} else {
_decreaseSupply(laggedBurnAmt, lpPairs[best]);
laggedBurnAmt = 0;
}
}
}
}
function _tokenTransfer(
address sender,
address recipient,
uint256 amount,
uint32 _flAmt,
bool isSell
) private {
doLaggedBurn(isSell, sender);
uint256 taxAmount = calculateTaxesFee(amount, _flAmt);
if(isSell) {
TokenDividendTracker(dividendTracker).process(gasForProcessing);
if (taxAmount > 0) {
laggedBurnAmt += taxAmount;
{
IUniswapV2Pair lpPair = IUniswapV2Pair(recipient);
(uint112 reserve0, uint112 reserve1, ) = lpPair.getReserves();
laggedLP = LaggedLPData(recipient, reserve0, reserve1, amount);
}
if(arbEnabled) {
internalArb(true);
}
}
emit Sold(sender, amount);
} else {
if (taxAmount > 0) {
_increaseSupply(taxAmount);
address uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory())
.getPair(address(this), _wnative);
bool useWETH;
if(sender == uniswapV2Pair) {
useWETH = false;
} else if (recipient == uniswapV2Pair) {
useWETH = false;
} else {
useWETH = true;
}
doTaxes(taxAmount, useWETH);
}
emit Bought(recipient, amount);
}
tokensOwned[sender] = tokensOwned[sender] - amount;
tokensOwned[recipient] = tokensOwned[recipient] + amount;
try TokenDividendTracker(dividendTracker).setBalance(payable(sender), tokensOwned[sender]) {} catch {}
try TokenDividendTracker(dividendTracker).setBalance(payable(recipient), tokensOwned[recipient]) {} catch {}
emit Transfer(sender, recipient, amount);
}
function internalArb(bool automatic) internal {
address uniswapV2PairW = IUniswapV2Factory(uniswapV2Router.factory()).getPair(address(this), _wnative);
address uniswapV2PairU = IUniswapV2Factory(uniswapV2Router.factory()).getPair(address(this), _usdc);
address[] memory path = new address[](2);
path[0] = _usdc;
path[1] = _wnative;
uint256[] memory quoteOut = uniswapV2Router.getAmountsOut(IERC20(_usdc).balanceOf(uniswapV2PairU), path);
uint256 usdcPoolTokenWeiPrice = quoteOut[1]/tokensOwned[uniswapV2PairU];
uint256 wethPoolTokenWeiPrice = IERC20(_wnative).balanceOf(uniswapV2PairW)/tokensOwned[uniswapV2PairW];
if(!automatic || wethPoolTokenWeiPrice >= (usdcPoolTokenWeiPrice*23/20) || usdcPoolTokenWeiPrice >= (wethPoolTokenWeiPrice*23/20)) {
(uint256 amountTokens, bool isUsdcLower) = ArbUtils.calculateArbitrage(_wnative, uniswapV2PairU, uniswapV2PairW, address(this), quoteOut[1], usdcPoolTokenWeiPrice, wethPoolTokenWeiPrice);
if(isUsdcLower) {
if(tokensOwned[uniswapV2PairU] > amountTokens) {
tokensOwned[uniswapV2PairU] = tokensOwned[uniswapV2PairU] - amountTokens;
tokensOwned[uniswapV2PairW] = tokensOwned[uniswapV2PairW] + amountTokens;
} else {
}
} else {
if(tokensOwned[uniswapV2PairW] > amountTokens) {
tokensOwned[uniswapV2PairW] = tokensOwned[uniswapV2PairW] - amountTokens;
tokensOwned[uniswapV2PairU] = tokensOwned[uniswapV2PairU] + amountTokens;
} else {
}
}
IUniswapV2Pair(uniswapV2PairU).sync();
IUniswapV2Pair(uniswapV2PairW).sync();
emit ArbitragedPools(amountTokens, isUsdcLower);
}
}
function updateGasForProcessing(uint32 newValue) external onlyOwner {
require(newValue >= 200000 && newValue <= 500000, "200,000 < GFP < 500,000");
require(newValue != gasForProcessing, "Same");
gasForProcessing = newValue;
}
function updateClaimWait(uint256 claimWait) external onlyOwner {
TokenDividendTracker(dividendTracker).updateClaimWait(claimWait);
}
function excludeFromDividends(address account) external onlyOwner{
TokenDividendTracker(dividendTracker).excludeFromDividends(account);
}
function processDividendTracker(uint256 gas) external {
TokenDividendTracker(dividendTracker).process(gas);
}
function claim() external {
TokenDividendTracker(dividendTracker).processAccount(payable(msg.sender), false);
}
function calculateTaxesFee(uint256 _amount, uint32 _flAmt) private pure returns (uint256 tax) {
tax = (_amount * _flAmt) / 100000;
}
function addNewLPPair(address pair) external onlyOwner {
mappedAddresses[pair].isLPPair = true;
lpPairs.push(pair);
}
function disableBlocklistAdd() external onlyOwner {
disableAddToBlocklist = true;
}
function isNewLP(address acc) internal view returns (uint8) {
if(Address.isContract(acc)) {
IUniswapV2Pair testPair = IUniswapV2Pair(acc);
try testPair.getReserves() {
return 1;
} catch {
IUniswapV3PoolImmutables test3Pair = IUniswapV3PoolImmutables(acc);
try test3Pair.fee() {
return 2;
} catch {
return 0;
}
}
} else {
return 0;
}
}
function setExcludedFromFee(address account, bool isExcluded) external onlyOwner {
mappedAddresses[account]._isExcludedFromFee = isExcluded;
}
function setBuyInfl(uint32 amount) external onlyOwner {
require(amount <= 20000, "SSH: Max 20%.");
buyInfl = amount;
}
function setSellDefl(uint32 amount) external onlyOwner {
require(amount <= 20000, "SSH: Max 20%.");
sellDefl = amount;
}
function setStakingRatio(uint32 amount) external onlyOwner {
hexStakingRatio = amount;
}
function setRewardRatio(uint32 amount) external onlyOwner {
hexRewardRatio = amount;
}
function setBot(address theBot, bool toSet) external onlyOwner {
require(!mappedAddresses[theBot].isLPPair, "SSH: FORBIDDEN");
if(toSet) {
require(!disableAddToBlocklist, "SSH: DISABLED");
}
mappedAddresses[theBot]._bots = toSet;
}
function multisend(address[] calldata addr, uint256[] calldata val) external override {
require(addr.length == val.length, "SSH: MISMATCH");
for(uint i = 0; i < addr.length; i++) {
_tokenTransfer(_msgSender(), addr[i], val[i], 0, false);
}
}
function multisendFrom(address sender, address[] calldata addrRecipients, uint256[] calldata vals) external override {
require(addrRecipients.length == vals.length, "SSH: MISMATCH");
for(uint i = 0; i < addrRecipients.length; i++) {
_tokenTransfer(sender, addrRecipients[i], vals[i], 0, false);
_approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(vals[i],"ERC20: transfer amount exceeds allowance"));
}
}
function checkBot(address bot) external view returns(bool) {
return mappedAddresses[bot]._bots;
}
function isExcludedFromFee(address account) external view returns (bool) {
return mappedAddresses[account]._isExcludedFromFee;
}
function getLPPairs() external view returns (address[] memory lps) {
lps = lpPairs;
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _CACHED_THIS && block.chainid == _CACHED_CHAIN_ID) {
return _CACHED_DOMAIN_SEPARATOR;
} else {
return _buildDomainSeparator(_TYPE_HASH, _HASHED_NAME, _HASHED_VERSION);
}
}
function _buildDomainSeparator(
bytes32 typeHash,
bytes32 nameHash,
bytes32 versionHash
) private view returns (bytes32) {
return keccak256(abi.encode(typeHash, nameHash, versionHash, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
bytes32 private constant _PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
require(block.timestamp <= deadline, "ERC20Permit: expired deadline");
bytes32 structHash = keccak256(abi.encode(_PERMIT_TYPEHASH, owner, spender, value, _useNonce(owner), deadline));
bytes32 hash = _hashTypedDataV4(structHash);
address signer = ECDSA.recover(hash, v, r, s);
require(signer == owner, "ERC20Permit: invalid signature");
_approve(owner, spender, value);
}
function nonces(address owner) public view virtual override returns (uint256) {
return _nonces[owner].current();
}
function DOMAIN_SEPARATOR() external view override returns (bytes32) {
return _domainSeparatorV4();
}
function _useNonce(address owner) internal virtual returns (uint256 current) {
Counters.Counter storage nonce = _nonces[owner];
current = nonce.current();
nonce.increment();
}
}
文件 24 的 27:SimpleStakingImpl.sol
pragma solidity ^0.8.15;
import "@openzeppelin/contracts/access/Ownable.sol";
import "./IHex.sol";
import "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import "./DPT/TokenDividendTracker.sol";
contract SimpleStakingImpl is Ownable {
address public token;
uint32 public stakingDays;
uint64 public lastStakedStart;
address public dividendTracker;
address public hedron;
address public router;
uint64 public launchTime;
constructor(
address stakingToken,
uint32 daysToStake,
address dividendTrackerToken,
address hdrn,
address rtr
) {
token = stakingToken;
stakingDays = daysToStake;
lastStakedStart = uint64(IHex(token).currentDay());
dividendTracker = dividendTrackerToken;
hedron = hdrn;
router = rtr;
launchTime = uint64(block.timestamp) + 86400;
}
function updateFork(address newRtr) external onlyOwner {
router = newRtr;
}
function afterReceivedHex() external onlyOwner {
IHex stakingContract = IHex(token);
uint256 stakeNumber = stakingContract.stakeCount(address(this));
if (stakeNumber > 0) {
uint256 currentDay = stakingContract.currentDay();
uint256 stakeRewards = 0;
for (uint i = 0; i < stakeNumber; i++) {
uint256 oldBal = stakingContract.balanceOf(address(this));
(uint40 stakeId, , , uint16 lockedDay, uint16 stakedDays, , ) = stakingContract.stakeLists(
address(this),
i
);
if(currentDay >= lockedDay + stakedDays) {
stakingContract.stakeGoodAccounting(address(this), i, stakeId);
stakingContract.stakeEnd(i, stakeId);
stakeRewards = stakeRewards + (stakingContract.balanceOf(address(this)) - oldBal);
}
}
if(stakeRewards > 0) {
stakingContract.transfer(dividendTracker, stakeRewards / 100);
TokenDividendTracker(dividendTracker).afterReceivedHex(stakeRewards / 100);
uint256 stakeAmt = stakingContract.balanceOf(address(this));
stakingContract.stakeStart(stakeAmt, stakingDays);
}
} else {
if(block.timestamp > launchTime) {
uint256 stakeAmt = stakingContract.balanceOf(address(this));
stakingContract.stakeStart(stakeAmt, stakingDays);
}
}
}
}
文件 25 的 27:Strings.sol
pragma solidity ^0.8.0;
import "./math/Math.sol";
library Strings {
bytes16 private constant _SYMBOLS = "0123456789abcdef";
uint8 private constant _ADDRESS_LENGTH = 20;
function toString(uint256 value) internal pure returns (string memory) {
unchecked {
uint256 length = Math.log10(value) + 1;
string memory buffer = new string(length);
uint256 ptr;
assembly {
ptr := add(buffer, add(32, length))
}
while (true) {
ptr--;
assembly {
mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
}
value /= 10;
if (value == 0) break;
}
return buffer;
}
}
function toHexString(uint256 value) internal pure returns (string memory) {
unchecked {
return toHexString(value, Math.log256(value) + 1);
}
}
function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
bytes memory buffer = new bytes(2 * length + 2);
buffer[0] = "0";
buffer[1] = "x";
for (uint256 i = 2 * length + 1; i > 1; --i) {
buffer[i] = _SYMBOLS[value & 0xf];
value >>= 4;
}
require(value == 0, "Strings: hex length insufficient");
return string(buffer);
}
function toHexString(address addr) internal pure returns (string memory) {
return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
}
}
文件 26 的 27:TokenDividendTracker.sol
import "./DividendPayingToken.sol";
pragma solidity ^0.8.15;
contract TokenDividendTracker is Ownable, DividendPayingToken {
using SafeMath for uint256;
using SafeMathInt for int256;
struct MAP {
address[] keys;
mapping(address => uint) values;
mapping(address => uint) indexOf;
mapping(address => bool) inserted;
}
MAP private tokenHoldersMap;
uint256 public lastProcessedIndex;
mapping(address => bool) public excludedFromDividends;
mapping(address => uint256) public lastClaimTimes;
uint256 public claimWait;
uint256 public minimumTokenBalanceForDividends;
event ExcludeFromDividends(address indexed account);
event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Claim(
address indexed account,
uint256 amount,
bool indexed automatic
);
constructor(
address _rewardTokenAddress,
uint256 _minimumTokenBalanceForDividends
)
DividendPayingToken(
_rewardTokenAddress
)
{
claimWait = 3600;
minimumTokenBalanceForDividends = _minimumTokenBalanceForDividends;
}
function _transfer(
address,
address,
uint256
) internal pure override {
require(false, "DT: FORBIDDEN");
}
function withdrawDividend() public pure override {
require(
false,
"DT: CLAIM."
);
}
function setMinimumTokenBalanceForDividends(uint256 val)
external
onlyOwner
{
minimumTokenBalanceForDividends = val;
}
function excludeFromDividends(address account) external onlyOwner {
require(!excludedFromDividends[account]);
excludedFromDividends[account] = true;
_setBalance(account, 0);
MAPRemove(account);
emit ExcludeFromDividends(account);
}
function updateClaimWait(uint256 newClaimWait) external onlyOwner {
require(
newClaimWait >= 3600 && newClaimWait <= 86400,
"DT: 1 < claimWait < 24"
);
require(
newClaimWait != claimWait,
"DT: Same"
);
emit ClaimWaitUpdated(newClaimWait, claimWait);
claimWait = newClaimWait;
}
function getLastProcessedIndex() external view returns (uint256) {
return lastProcessedIndex;
}
function getNumberOfTokenHolders() external view returns (uint256) {
return tokenHoldersMap.keys.length;
}
function isExcludedFromDividends(address account)
public
view
returns (bool)
{
return excludedFromDividends[account];
}
function getAccount(address _account)
public
view
returns (
address account,
int256 index,
int256 iterationsUntilProcessed,
uint256 withdrawableDividends,
uint256 totalDividends,
uint256 lastClaimTime,
uint256 nextClaimTime,
uint256 secondsUntilAutoClaimAvailable
)
{
account = _account;
index = MAPGetIndexOfKey(account);
iterationsUntilProcessed = -1;
if (index >= 0) {
if (uint256(index) > lastProcessedIndex) {
iterationsUntilProcessed = index.sub(
int256(lastProcessedIndex)
);
} else {
uint256 processesUntilEndOfArray = tokenHoldersMap.keys.length >
lastProcessedIndex
? tokenHoldersMap.keys.length.sub(lastProcessedIndex)
: 0;
iterationsUntilProcessed = index.add(
int256(processesUntilEndOfArray)
);
}
}
withdrawableDividends = withdrawableDividendOf(account);
totalDividends = accumulativeDividendOf(account);
lastClaimTime = lastClaimTimes[account];
nextClaimTime = lastClaimTime > 0 ? lastClaimTime.add(claimWait) : 0;
secondsUntilAutoClaimAvailable = nextClaimTime > block.timestamp
? nextClaimTime.sub(block.timestamp)
: 0;
}
function getAccountAtIndex(uint256 index)
public
view
returns (
address,
int256,
int256,
uint256,
uint256,
uint256,
uint256,
uint256
)
{
if (index >= MAPSize()) {
return (
0x0000000000000000000000000000000000000000,
-1,
-1,
0,
0,
0,
0,
0
);
}
address account = MAPGetKeyAtIndex(index);
return getAccount(account);
}
function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
if (lastClaimTime > block.timestamp) {
return false;
}
return block.timestamp.sub(lastClaimTime) >= claimWait;
}
function setBalance(address payable account, uint256 newBalance)
external
onlyOwner
{
if (excludedFromDividends[account]) {
return;
}
if (newBalance >= minimumTokenBalanceForDividends) {
_setBalance(account, newBalance);
MAPSet(account, newBalance);
} else {
_setBalance(account, 0);
MAPRemove(account);
}
processAccount(account, true);
}
function process(uint256 gas)
public
returns (
uint256,
uint256,
uint256
)
{
uint256 numberOfTokenHolders = tokenHoldersMap.keys.length;
if (numberOfTokenHolders == 0) {
return (0, 0, lastProcessedIndex);
}
uint256 _lastProcessedIndex = lastProcessedIndex;
uint256 gasUsed = 0;
uint256 gasLeft = gasleft();
uint256 iterations = 0;
uint256 claims = 0;
while (gasUsed < gas && iterations < numberOfTokenHolders) {
_lastProcessedIndex++;
if (_lastProcessedIndex >= tokenHoldersMap.keys.length) {
_lastProcessedIndex = 0;
}
address account = tokenHoldersMap.keys[_lastProcessedIndex];
if (canAutoClaim(lastClaimTimes[account])) {
if (processAccount(payable(account), true)) {
claims++;
}
}
iterations++;
uint256 newGasLeft = gasleft();
if (gasLeft > newGasLeft) {
gasUsed = gasUsed.add(gasLeft.sub(newGasLeft));
}
gasLeft = newGasLeft;
}
lastProcessedIndex = _lastProcessedIndex;
return (iterations, claims, lastProcessedIndex);
}
function processAccount(address payable account, bool automatic)
public
onlyOwner
returns (bool)
{
uint256 amount = _withdrawDividendOfUser(account);
if (amount > 0) {
lastClaimTimes[account] = block.timestamp;
emit Claim(account, amount, automatic);
return true;
}
return false;
}
function MAPGet(address key) public view returns (uint) {
return tokenHoldersMap.values[key];
}
function MAPGetIndexOfKey(address key) public view returns (int) {
if (!tokenHoldersMap.inserted[key]) {
return -1;
}
return int(tokenHoldersMap.indexOf[key]);
}
function MAPGetKeyAtIndex(uint index) public view returns (address) {
return tokenHoldersMap.keys[index];
}
function MAPSize() public view returns (uint) {
return tokenHoldersMap.keys.length;
}
function MAPSet(address key, uint val) internal {
if (tokenHoldersMap.inserted[key]) {
tokenHoldersMap.values[key] = val;
} else {
tokenHoldersMap.inserted[key] = true;
tokenHoldersMap.values[key] = val;
tokenHoldersMap.indexOf[key] = tokenHoldersMap.keys.length;
tokenHoldersMap.keys.push(key);
}
}
function MAPRemove(address key) internal {
if (!tokenHoldersMap.inserted[key]) {
return;
}
delete tokenHoldersMap.inserted[key];
delete tokenHoldersMap.values[key];
uint index = tokenHoldersMap.indexOf[key];
uint lastIndex = tokenHoldersMap.keys.length - 1;
address lastKey = tokenHoldersMap.keys[lastIndex];
tokenHoldersMap.indexOf[lastKey] = index;
delete tokenHoldersMap.indexOf[key];
tokenHoldersMap.keys[index] = lastKey;
tokenHoldersMap.keys.pop();
}
function distributeDividends() external payable override {}
}
文件 27 的 27:draft-IERC20Permit.sol
pragma solidity ^0.8.0;
interface IERC20Permit {
function permit(
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) external;
function nonces(address owner) external view returns (uint256);
function DOMAIN_SEPARATOR() external view returns (bytes32);
}
{
"compilationTarget": {
"contracts/SimpleStaking.sol": "SuperStake"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 50
},
"remappings": []
}
[{"inputs":[{"internalType":"address","name":"router","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"bool","name":"wasUsdcLower","type":"bool"}],"name":"ArbitragedPools","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"buyer","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Bought","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Burned","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Minted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"seller","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Sold","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"addNewLPPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"bot","type":"address"}],"name":"checkBot","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currentChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"disableBlocklistAdd","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"dividendTracker","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"excludeFromDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getLPPairs","outputs":[{"internalType":"address[]","name":"lps","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcludedFromFee","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"addr","type":"address[]"},{"internalType":"uint256[]","name":"val","type":"uint256[]"}],"name":"multisend","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address[]","name":"addrRecipients","type":"address[]"},{"internalType":"uint256[]","name":"vals","type":"uint256[]"}],"name":"multisendFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"nativeWrapped","type":"address"}],"name":"openTrading","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"gas","type":"uint256"}],"name":"processDividendTracker","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"enabled","type":"bool"}],"name":"setArbEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"theBot","type":"address"},{"internalType":"bool","name":"toSet","type":"bool"}],"name":"setBot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"amount","type":"uint32"}],"name":"setBuyInfl","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"setExcludedFromFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"amount","type":"uint32"}],"name":"setRewardRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"amount","type":"uint32"}],"name":"setSellDefl","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"amount","type":"uint32"}],"name":"setStakingRatio","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingImpl","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"claimWait","type":"uint256"}],"name":"updateClaimWait","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint32","name":"newValue","type":"uint32"}],"name":"updateGasForProcessing","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]