文件 1 的 1：DividendsTokenCustomLaunch.sol
pragma solidity ^0.8.18;
interface IERC20 {
event Transfer(address indexed from, address indexed to, uint256 value);
event Approval(address indexed owner, address indexed spender, uint256 value);
function totalSupply() external view returns (uint256);
function balanceOf(address account) external view returns (uint256);
function transfer(address to, uint256 amount) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 amount) external returns (bool);
function transferFrom(address from, address to, uint256 amount) external returns (bool);
}
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
}
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
function name() public view virtual override returns (string memory) {
return _name;
}
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
function decimals() public view virtual override returns (uint8) {
return 18;
}
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
function _approve(address owner, address spender, uint256 amount) internal virtual {
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 _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}
}
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);
}
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;
}
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;
}
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;
}
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;
}
}
}
abstract contract Ownable is Context {
address _owner;
event OwnershipTransferred(
address indexed previousOwner,
address indexed newOwner
);
constructor(address _ownerAddress) {
_transferOwnership(_ownerAddress);
}
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);
}
}
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);
}
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);
}
}
}
library SafeERC20 {
using Address for address;
function safeTransfer(IERC20 token, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
}
function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
_callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
}
function safeApprove(IERC20 token, address spender, uint256 value) internal {
require(
(value == 0) || (token.allowance(address(this), spender) == 0),
"SafeERC20: approve from non-zero to non-zero allowance"
);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
}
function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
uint256 oldAllowance = token.allowance(address(this), spender);
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance + value));
}
function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
unchecked {
uint256 oldAllowance = token.allowance(address(this), spender);
require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, oldAllowance - value));
}
}
function forceApprove(IERC20 token, address spender, uint256 value) internal {
bytes memory approvalCall = abi.encodeWithSelector(token.approve.selector, spender, value);
if (!_callOptionalReturnBool(token, approvalCall)) {
_callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, 0));
_callOptionalReturn(token, approvalCall);
}
}
function safePermit(
IERC20Permit token,
address owner,
address spender,
uint256 value,
uint256 deadline,
uint8 v,
bytes32 r,
bytes32 s
) internal {
uint256 nonceBefore = token.nonces(owner);
token.permit(owner, spender, value, deadline, v, r, s);
uint256 nonceAfter = token.nonces(owner);
require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
}
function _callOptionalReturn(IERC20 token, bytes memory data) private {
bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
require(returndata.length == 0 || abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
}
function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
(bool success, bytes memory returndata) = address(token).call(data);
return
success && (returndata.length == 0 || abi.decode(returndata, (bool))) && Address.isContract(address(token));
}
}
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, "Math: mulDiv overflow");
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 << 3) < value ? 1 : 0);
}
}
}
library SignedMath {
function max(int256 a, int256 b) internal pure returns (int256) {
return a > b ? a : b;
}
function min(int256 a, int256 b) internal pure returns (int256) {
return a < b ? a : b;
}
function average(int256 a, int256 b) internal pure returns (int256) {
int256 x = (a & b) + ((a ^ b) >> 1);
return x + (int256(uint256(x) >> 255) & (a ^ b));
}
function abs(int256 n) internal pure returns (uint256) {
unchecked {
return uint256(n >= 0 ? n : -n);
}
}
}
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 toString(int256 value) internal pure returns (string memory) {
return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
}
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);
}
function equal(string memory a, string memory b) internal pure returns (bool) {
return keccak256(bytes(a)) == keccak256(bytes(b));
}
}
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 message) {
assembly {
mstore(0x00, "\x19Ethereum Signed Message:\n32")
mstore(0x1c, hash)
message := keccak256(0x00, 0x3c)
}
}
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 data) {
assembly {
let ptr := mload(0x40)
mstore(ptr, "\x19\x01")
mstore(add(ptr, 0x02), domainSeparator)
mstore(add(ptr, 0x22), structHash)
data := keccak256(ptr, 0x42)
}
}
function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
return keccak256(abi.encodePacked("\x19\x00", validator, data));
}
}
library StorageSlot {
struct AddressSlot {
address value;
}
struct BooleanSlot {
bool value;
}
struct Bytes32Slot {
bytes32 value;
}
struct Uint256Slot {
uint256 value;
}
struct StringSlot {
string value;
}
struct BytesSlot {
bytes value;
}
function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
assembly {
r.slot := slot
}
}
function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
assembly {
r.slot := slot
}
}
function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
assembly {
r.slot := slot
}
}
function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
assembly {
r.slot := store.slot
}
}
function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := slot
}
}
function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
assembly {
r.slot := store.slot
}
}
}
type ShortString is bytes32;
library ShortStrings {
bytes32 private constant _FALLBACK_SENTINEL = 0x00000000000000000000000000000000000000000000000000000000000000FF;
error StringTooLong(string str);
error InvalidShortString();
function toShortString(string memory str) internal pure returns (ShortString) {
bytes memory bstr = bytes(str);
if (bstr.length > 31) {
revert StringTooLong(str);
}
return ShortString.wrap(bytes32(uint256(bytes32(bstr)) | bstr.length));
}
function toString(ShortString sstr) internal pure returns (string memory) {
uint256 len = byteLength(sstr);
string memory str = new string(32);
assembly {
mstore(str, len)
mstore(add(str, 0x20), sstr)
}
return str;
}
function byteLength(ShortString sstr) internal pure returns (uint256) {
uint256 result = uint256(ShortString.unwrap(sstr)) & 0xFF;
if (result > 31) {
revert InvalidShortString();
}
return result;
}
function toShortStringWithFallback(string memory value, string storage store) internal returns (ShortString) {
if (bytes(value).length < 32) {
return toShortString(value);
} else {
StorageSlot.getStringSlot(store).value = value;
return ShortString.wrap(_FALLBACK_SENTINEL);
}
}
function toStringWithFallback(ShortString value, string storage store) internal pure returns (string memory) {
if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
return toString(value);
} else {
return store;
}
}
function byteLengthWithFallback(ShortString value, string storage store) internal view returns (uint256) {
if (ShortString.unwrap(value) != _FALLBACK_SENTINEL) {
return byteLength(value);
} else {
return bytes(store).length;
}
}
}
interface IERC5267 {
event EIP712DomainChanged();
function eip712Domain()
external
view
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
);
}
abstract contract EIP712 is IERC5267 {
using ShortStrings for *;
bytes32 private constant _TYPE_HASH =
keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");
bytes32 private immutable _cachedDomainSeparator;
uint256 private immutable _cachedChainId;
address private immutable _cachedThis;
bytes32 private immutable _hashedName;
bytes32 private immutable _hashedVersion;
ShortString private immutable _name;
ShortString private immutable _version;
string private _nameFallback;
string private _versionFallback;
constructor(string memory name, string memory version) {
_name = name.toShortStringWithFallback(_nameFallback);
_version = version.toShortStringWithFallback(_versionFallback);
_hashedName = keccak256(bytes(name));
_hashedVersion = keccak256(bytes(version));
_cachedChainId = block.chainid;
_cachedDomainSeparator = _buildDomainSeparator();
_cachedThis = address(this);
}
function _domainSeparatorV4() internal view returns (bytes32) {
if (address(this) == _cachedThis && block.chainid == _cachedChainId) {
return _cachedDomainSeparator;
} else {
return _buildDomainSeparator();
}
}
function _buildDomainSeparator() private view returns (bytes32) {
return keccak256(abi.encode(_TYPE_HASH, _hashedName, _hashedVersion, block.chainid, address(this)));
}
function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
return ECDSA.toTypedDataHash(_domainSeparatorV4(), structHash);
}
function eip712Domain()
public
view
virtual
override
returns (
bytes1 fields,
string memory name,
string memory version,
uint256 chainId,
address verifyingContract,
bytes32 salt,
uint256[] memory extensions
)
{
return (
hex"0f",
_name.toStringWithFallback(_nameFallback),
_version.toStringWithFallback(_versionFallback),
block.chainid,
address(this),
bytes32(0),
new uint256[](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;
}
}
abstract contract ERC20Permit is ERC20, IERC20Permit, EIP712 {
using Counters for Counters.Counter;
mapping(address => Counters.Counter) private _nonces;
bytes32 private constant _PERMIT_TYPEHASH =
keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
bytes32 private _PERMIT_TYPEHASH_DEPRECATED_SLOT;
constructor(string memory name) EIP712(name, "1") {}
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();
}
}
interface IVotes {
event DelegateChanged(address indexed delegator, address indexed fromDelegate, address indexed toDelegate);
event DelegateVotesChanged(address indexed delegate, uint256 previousBalance, uint256 newBalance);
function getVotes(address account) external view returns (uint256);
function getPastVotes(address account, uint256 timepoint) external view returns (uint256);
function getPastTotalSupply(uint256 timepoint) external view returns (uint256);
function delegates(address account) external view returns (address);
function delegate(address delegatee) external;
function delegateBySig(address delegatee, uint256 nonce, uint256 expiry, uint8 v, bytes32 r, bytes32 s) external;
}
interface IERC6372 {
function clock() external view returns (uint48);
function CLOCK_MODE() external view returns (string memory);
}
interface IERC5805 is IERC6372, IVotes {}
library SafeCast {
function toUint248(uint256 value) internal pure returns (uint248) {
require(value <= type(uint248).max, "SafeCast: value doesn't fit in 248 bits");
return uint248(value);
}
function toUint240(uint256 value) internal pure returns (uint240) {
require(value <= type(uint240).max, "SafeCast: value doesn't fit in 240 bits");
return uint240(value);
}
function toUint232(uint256 value) internal pure returns (uint232) {
require(value <= type(uint232).max, "SafeCast: value doesn't fit in 232 bits");
return uint232(value);
}
function toUint224(uint256 value) internal pure returns (uint224) {
require(value <= type(uint224).max, "SafeCast: value doesn't fit in 224 bits");
return uint224(value);
}
function toUint216(uint256 value) internal pure returns (uint216) {
require(value <= type(uint216).max, "SafeCast: value doesn't fit in 216 bits");
return uint216(value);
}
function toUint208(uint256 value) internal pure returns (uint208) {
require(value <= type(uint208).max, "SafeCast: value doesn't fit in 208 bits");
return uint208(value);
}
function toUint200(uint256 value) internal pure returns (uint200) {
require(value <= type(uint200).max, "SafeCast: value doesn't fit in 200 bits");
return uint200(value);
}
function toUint192(uint256 value) internal pure returns (uint192) {
require(value <= type(uint192).max, "SafeCast: value doesn't fit in 192 bits");
return uint192(value);
}
function toUint184(uint256 value) internal pure returns (uint184) {
require(value <= type(uint184).max, "SafeCast: value doesn't fit in 184 bits");
return uint184(value);
}
function toUint176(uint256 value) internal pure returns (uint176) {
require(value <= type(uint176).max, "SafeCast: value doesn't fit in 176 bits");
return uint176(value);
}
function toUint168(uint256 value) internal pure returns (uint168) {
require(value <= type(uint168).max, "SafeCast: value doesn't fit in 168 bits");
return uint168(value);
}
function toUint160(uint256 value) internal pure returns (uint160) {
require(value <= type(uint160).max, "SafeCast: value doesn't fit in 160 bits");
return uint160(value);
}
function toUint152(uint256 value) internal pure returns (uint152) {
require(value <= type(uint152).max, "SafeCast: value doesn't fit in 152 bits");
return uint152(value);
}
function toUint144(uint256 value) internal pure returns (uint144) {
require(value <= type(uint144).max, "SafeCast: value doesn't fit in 144 bits");
return uint144(value);
}
function toUint136(uint256 value) internal pure returns (uint136) {
require(value <= type(uint136).max, "SafeCast: value doesn't fit in 136 bits");
return uint136(value);
}
function toUint128(uint256 value) internal pure returns (uint128) {
require(value <= type(uint128).max, "SafeCast: value doesn't fit in 128 bits");
return uint128(value);
}
function toUint120(uint256 value) internal pure returns (uint120) {
require(value <= type(uint120).max, "SafeCast: value doesn't fit in 120 bits");
return uint120(value);
}
function toUint112(uint256 value) internal pure returns (uint112) {
require(value <= type(uint112).max, "SafeCast: value doesn't fit in 112 bits");
return uint112(value);
}
function toUint104(uint256 value) internal pure returns (uint104) {
require(value <= type(uint104).max, "SafeCast: value doesn't fit in 104 bits");
return uint104(value);
}
function toUint96(uint256 value) internal pure returns (uint96) {
require(value <= type(uint96).max, "SafeCast: value doesn't fit in 96 bits");
return uint96(value);
}
function toUint88(uint256 value) internal pure returns (uint88) {
require(value <= type(uint88).max, "SafeCast: value doesn't fit in 88 bits");
return uint88(value);
}
function toUint80(uint256 value) internal pure returns (uint80) {
require(value <= type(uint80).max, "SafeCast: value doesn't fit in 80 bits");
return uint80(value);
}
function toUint72(uint256 value) internal pure returns (uint72) {
require(value <= type(uint72).max, "SafeCast: value doesn't fit in 72 bits");
return uint72(value);
}
function toUint64(uint256 value) internal pure returns (uint64) {
require(value <= type(uint64).max, "SafeCast: value doesn't fit in 64 bits");
return uint64(value);
}
function toUint56(uint256 value) internal pure returns (uint56) {
require(value <= type(uint56).max, "SafeCast: value doesn't fit in 56 bits");
return uint56(value);
}
function toUint48(uint256 value) internal pure returns (uint48) {
require(value <= type(uint48).max, "SafeCast: value doesn't fit in 48 bits");
return uint48(value);
}
function toUint40(uint256 value) internal pure returns (uint40) {
require(value <= type(uint40).max, "SafeCast: value doesn't fit in 40 bits");
return uint40(value);
}
function toUint32(uint256 value) internal pure returns (uint32) {
require(value <= type(uint32).max, "SafeCast: value doesn't fit in 32 bits");
return uint32(value);
}
function toUint24(uint256 value) internal pure returns (uint24) {
require(value <= type(uint24).max, "SafeCast: value doesn't fit in 24 bits");
return uint24(value);
}
function toUint16(uint256 value) internal pure returns (uint16) {
require(value <= type(uint16).max, "SafeCast: value doesn't fit in 16 bits");
return uint16(value);
}
function toUint8(uint256 value) internal pure returns (uint8) {
require(value <= type(uint8).max, "SafeCast: value doesn't fit in 8 bits");
return uint8(value);
}
function toUint256(int256 value) internal pure returns (uint256) {
require(value >= 0, "SafeCast: value must be positive");
return uint256(value);
}
function toInt248(int256 value) internal pure returns (int248 downcasted) {
downcasted = int248(value);
require(downcasted == value, "SafeCast: value doesn't fit in 248 bits");
}
function toInt240(int256 value) internal pure returns (int240 downcasted) {
downcasted = int240(value);
require(downcasted == value, "SafeCast: value doesn't fit in 240 bits");
}
function toInt232(int256 value) internal pure returns (int232 downcasted) {
downcasted = int232(value);
require(downcasted == value, "SafeCast: value doesn't fit in 232 bits");
}
function toInt224(int256 value) internal pure returns (int224 downcasted) {
downcasted = int224(value);
require(downcasted == value, "SafeCast: value doesn't fit in 224 bits");
}
function toInt216(int256 value) internal pure returns (int216 downcasted) {
downcasted = int216(value);
require(downcasted == value, "SafeCast: value doesn't fit in 216 bits");
}
function toInt208(int256 value) internal pure returns (int208 downcasted) {
downcasted = int208(value);
require(downcasted == value, "SafeCast: value doesn't fit in 208 bits");
}
function toInt200(int256 value) internal pure returns (int200 downcasted) {
downcasted = int200(value);
require(downcasted == value, "SafeCast: value doesn't fit in 200 bits");
}
function toInt192(int256 value) internal pure returns (int192 downcasted) {
downcasted = int192(value);
require(downcasted == value, "SafeCast: value doesn't fit in 192 bits");
}
function toInt184(int256 value) internal pure returns (int184 downcasted) {
downcasted = int184(value);
require(downcasted == value, "SafeCast: value doesn't fit in 184 bits");
}
function toInt176(int256 value) internal pure returns (int176 downcasted) {
downcasted = int176(value);
require(downcasted == value, "SafeCast: value doesn't fit in 176 bits");
}
function toInt168(int256 value) internal pure returns (int168 downcasted) {
downcasted = int168(value);
require(downcasted == value, "SafeCast: value doesn't fit in 168 bits");
}
function toInt160(int256 value) internal pure returns (int160 downcasted) {
downcasted = int160(value);
require(downcasted == value, "SafeCast: value doesn't fit in 160 bits");
}
function toInt152(int256 value) internal pure returns (int152 downcasted) {
downcasted = int152(value);
require(downcasted == value, "SafeCast: value doesn't fit in 152 bits");
}
function toInt144(int256 value) internal pure returns (int144 downcasted) {
downcasted = int144(value);
require(downcasted == value, "SafeCast: value doesn't fit in 144 bits");
}
function toInt136(int256 value) internal pure returns (int136 downcasted) {
downcasted = int136(value);
require(downcasted == value, "SafeCast: value doesn't fit in 136 bits");
}
function toInt128(int256 value) internal pure returns (int128 downcasted) {
downcasted = int128(value);
require(downcasted == value, "SafeCast: value doesn't fit in 128 bits");
}
function toInt120(int256 value) internal pure returns (int120 downcasted) {
downcasted = int120(value);
require(downcasted == value, "SafeCast: value doesn't fit in 120 bits");
}
function toInt112(int256 value) internal pure returns (int112 downcasted) {
downcasted = int112(value);
require(downcasted == value, "SafeCast: value doesn't fit in 112 bits");
}
function toInt104(int256 value) internal pure returns (int104 downcasted) {
downcasted = int104(value);
require(downcasted == value, "SafeCast: value doesn't fit in 104 bits");
}
function toInt96(int256 value) internal pure returns (int96 downcasted) {
downcasted = int96(value);
require(downcasted == value, "SafeCast: value doesn't fit in 96 bits");
}
function toInt88(int256 value) internal pure returns (int88 downcasted) {
downcasted = int88(value);
require(downcasted == value, "SafeCast: value doesn't fit in 88 bits");
}
function toInt80(int256 value) internal pure returns (int80 downcasted) {
downcasted = int80(value);
require(downcasted == value, "SafeCast: value doesn't fit in 80 bits");
}
function toInt72(int256 value) internal pure returns (int72 downcasted) {
downcasted = int72(value);
require(downcasted == value, "SafeCast: value doesn't fit in 72 bits");
}
function toInt64(int256 value) internal pure returns (int64 downcasted) {
downcasted = int64(value);
require(downcasted == value, "SafeCast: value doesn't fit in 64 bits");
}
function toInt56(int256 value) internal pure returns (int56 downcasted) {
downcasted = int56(value);
require(downcasted == value, "SafeCast: value doesn't fit in 56 bits");
}
function toInt48(int256 value) internal pure returns (int48 downcasted) {
downcasted = int48(value);
require(downcasted == value, "SafeCast: value doesn't fit in 48 bits");
}
function toInt40(int256 value) internal pure returns (int40 downcasted) {
downcasted = int40(value);
require(downcasted == value, "SafeCast: value doesn't fit in 40 bits");
}
function toInt32(int256 value) internal pure returns (int32 downcasted) {
downcasted = int32(value);
require(downcasted == value, "SafeCast: value doesn't fit in 32 bits");
}
function toInt24(int256 value) internal pure returns (int24 downcasted) {
downcasted = int24(value);
require(downcasted == value, "SafeCast: value doesn't fit in 24 bits");
}
function toInt16(int256 value) internal pure returns (int16 downcasted) {
downcasted = int16(value);
require(downcasted == value, "SafeCast: value doesn't fit in 16 bits");
}
function toInt8(int256 value) internal pure returns (int8 downcasted) {
downcasted = int8(value);
require(downcasted == value, "SafeCast: value doesn't fit in 8 bits");
}
function toInt256(uint256 value) internal pure returns (int256) {
require(value <= uint256(type(int256).max), "SafeCast: value doesn't fit in an int256");
return int256(value);
}
}
abstract contract ERC20Votes is ERC20Permit, IERC5805 {
struct Checkpoint {
uint32 fromBlock;
uint224 votes;
}
bytes32 private constant _DELEGATION_TYPEHASH =
keccak256("Delegation(address delegatee,uint256 nonce,uint256 expiry)");
mapping(address => address) private _delegates;
mapping(address => Checkpoint[]) private _checkpoints;
Checkpoint[] private _totalSupplyCheckpoints;
function clock() public view virtual override returns (uint48) {
return SafeCast.toUint48(block.number);
}
function CLOCK_MODE() public view virtual override returns (string memory) {
require(clock() == block.number, "ERC20Votes: broken clock mode");
return "mode=blocknumber&from=default";
}
function checkpoints(address account, uint32 pos) public view virtual returns (Checkpoint memory) {
return _checkpoints[account][pos];
}
function numCheckpoints(address account) public view virtual returns (uint32) {
return SafeCast.toUint32(_checkpoints[account].length);
}
function delegates(address account) public view virtual override returns (address) {
return _delegates[account];
}
function getVotes(address account) public view virtual override returns (uint256) {
uint256 pos = _checkpoints[account].length;
unchecked {
return pos == 0 ? 0 : _checkpoints[account][pos - 1].votes;
}
}
function getPastVotes(address account, uint256 timepoint) public view virtual override returns (uint256) {
require(timepoint < clock(), "ERC20Votes: future lookup");
return _checkpointsLookup(_checkpoints[account], timepoint);
}
function getPastTotalSupply(uint256 timepoint) public view virtual override returns (uint256) {
require(timepoint < clock(), "ERC20Votes: future lookup");
return _checkpointsLookup(_totalSupplyCheckpoints, timepoint);
}
function _checkpointsLookup(Checkpoint[] storage ckpts, uint256 timepoint) private view returns (uint256) {
uint256 length = ckpts.length;
uint256 low = 0;
uint256 high = length;
if (length > 5) {
uint256 mid = length - Math.sqrt(length);
if (_unsafeAccess(ckpts, mid).fromBlock > timepoint) {
high = mid;
} else {
low = mid + 1;
}
}
while (low < high) {
uint256 mid = Math.average(low, high);
if (_unsafeAccess(ckpts, mid).fromBlock > timepoint) {
high = mid;
} else {
low = mid + 1;
}
}
unchecked {
return high == 0 ? 0 : _unsafeAccess(ckpts, high - 1).votes;
}
}
function delegate(address delegatee) public virtual override {
_delegate(_msgSender(), delegatee);
}
function delegateBySig(
address delegatee,
uint256 nonce,
uint256 expiry,
uint8 v,
bytes32 r,
bytes32 s
) public virtual override {
require(block.timestamp <= expiry, "ERC20Votes: signature expired");
address signer = ECDSA.recover(
_hashTypedDataV4(keccak256(abi.encode(_DELEGATION_TYPEHASH, delegatee, nonce, expiry))),
v,
r,
s
);
require(nonce == _useNonce(signer), "ERC20Votes: invalid nonce");
_delegate(signer, delegatee);
}
function _maxSupply() internal view virtual returns (uint224) {
return type(uint224).max;
}
function _mint(address account, uint256 amount) internal virtual override {
super._mint(account, amount);
require(totalSupply() <= _maxSupply(), "ERC20Votes: total supply risks overflowing votes");
_writeCheckpoint(_totalSupplyCheckpoints, _add, amount);
}
function _burn(address account, uint256 amount) internal virtual override {
super._burn(account, amount);
_writeCheckpoint(_totalSupplyCheckpoints, _subtract, amount);
}
function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual override {
super._afterTokenTransfer(from, to, amount);
_moveVotingPower(delegates(from), delegates(to), amount);
}
function _delegate(address delegator, address delegatee) internal virtual {
address currentDelegate = delegates(delegator);
uint256 delegatorBalance = balanceOf(delegator);
_delegates[delegator] = delegatee;
emit DelegateChanged(delegator, currentDelegate, delegatee);
_moveVotingPower(currentDelegate, delegatee, delegatorBalance);
}
function _moveVotingPower(address src, address dst, uint256 amount) private {
if (src != dst && amount > 0) {
if (src != address(0)) {
(uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[src], _subtract, amount);
emit DelegateVotesChanged(src, oldWeight, newWeight);
}
if (dst != address(0)) {
(uint256 oldWeight, uint256 newWeight) = _writeCheckpoint(_checkpoints[dst], _add, amount);
emit DelegateVotesChanged(dst, oldWeight, newWeight);
}
}
}
function _writeCheckpoint(
Checkpoint[] storage ckpts,
function(uint256, uint256) view returns (uint256) op,
uint256 delta
) private returns (uint256 oldWeight, uint256 newWeight) {
uint256 pos = ckpts.length;
unchecked {
Checkpoint memory oldCkpt = pos == 0 ? Checkpoint(0, 0) : _unsafeAccess(ckpts, pos - 1);
oldWeight = oldCkpt.votes;
newWeight = op(oldWeight, delta);
if (pos > 0 && oldCkpt.fromBlock == clock()) {
_unsafeAccess(ckpts, pos - 1).votes = SafeCast.toUint224(newWeight);
} else {
ckpts.push(Checkpoint({fromBlock: SafeCast.toUint32(clock()), votes: SafeCast.toUint224(newWeight)}));
}
}
}
function _add(uint256 a, uint256 b) private pure returns (uint256) {
return a + b;
}
function _subtract(uint256 a, uint256 b) private pure returns (uint256) {
return a - b;
}
function _unsafeAccess(Checkpoint[] storage ckpts, uint256 pos) private pure returns (Checkpoint storage result) {
assembly {
mstore(0, ckpts.slot)
result.slot := add(keccak256(0, 0x20), pos)
}
}
}
abstract contract ERC20Decimals is ERC20 {
uint8 private immutable _decimals;
constructor(uint8 decimals_) {
_decimals = decimals_;
}
function decimals() public view virtual override returns (uint8) {
return _decimals;
}
}
abstract contract ERC20VotesDecimals is ERC20Votes {
uint8 private immutable _decimals;
constructor(uint8 decimals_) {
_decimals = decimals_;
}
function decimals() public view virtual override returns (uint8) {
return _decimals;
}
function _afterTokenTransfer(
address _from,
address _to,
uint256 _amount
) internal virtual override {
ERC20Votes._afterTokenTransfer(_from, _to, _amount);
}
}
struct ShareHolder {
uint256 shares;
uint256 rewardDebt;
uint256 claimed;
uint256 pending;
}
struct TaxInfo {
uint64 charity;
uint64 autoLiquidity;
uint64 marketing;
uint64 reflection;
}
struct DividendConstructorArgs {
address uniswapFactory;
IUniswapV2Router02 uniswapV2Router;
address mainLPToken;
address charityAddress;
address marketingAddress;
address autoLiquidityAddress;
TaxInfo transferTaxInfo;
TaxInfo buyTaxInfo;
TaxInfo sellTaxInfo;
bool swapTaxes;
uint256 minShareForRewards;
bool sameTokenForRewards;
}
contract ERC20TempHolder {
address immutable owner;
constructor() {
owner = msg.sender;
}
function transfer(address token, address to, uint256 amount) external {
require(msg.sender == owner, "Only owner");
IERC20(token).transfer(to, amount);
}
}
abstract contract DividendsTokenCustom is ERC20Decimals, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public minShareForRewards;
uint256 public maxAutoProcessGas = 500000;
bool public autoDistribute = true;
uint256 public accPerShare;
uint256 public totalShares;
uint256 public totalClaimed;
uint256 public totalRewardsDebt;
mapping(address => ShareHolder) shareHolders;
address[] public allShareHolders;
mapping(address => uint256) public indexOfShareHolders;
uint256 private _lastProccessedIndex = 1;
mapping(address => bool) public excludedFromRewards;
event Claimed(address indexed claimer, uint256 indexed amount);
event RewardsAdded(uint256 indexed amount);
event ShareUpdated(
address indexed shareHolder,
uint256 indexed sharesAmount
);
event IncludedInRewards(address indexed shareHolder);
event ExcludedFromRewards(address indexed shareHolder);
address public immutable weth;
address public immutable rewardToken;
bool immutable isWethRewardToken;
uint256 public constant PERCENT_DENOMINATOR = 1000;
uint256 public constant MAX_TAX = 200;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public immutable wrappedNativeAddress;
address public immutable mainLPToken;
ERC20TempHolder public immutable tempHolder = new ERC20TempHolder();
bool public immutable sameTokenForRewards;
address public charityAddress;
address public marketingAddress;
address public autoLiquidityAddress;
TaxInfo public transferTax;
TaxInfo public buyTax;
TaxInfo public sellTax;
bool public isTaxActive;
bool public swapAndLiquifyActive = true;
uint256 public minTokensBeforeSwap;
mapping(address => bool) public isExcludedFromFee;
mapping(address => bool) public isPair;
uint256 public charityReserves;
uint256 public marketingReserves;
uint256 public autoLiquidityReserves;
uint256 public reflectionReserves;
bool public swapTaxes;
function setSwapTaxes(bool _swapTaxes) external onlyOwner {
swapTaxes = _swapTaxes;
}
constructor(DividendConstructorArgs memory _args) {
minTokensBeforeSwap = (1 * 10) ** (decimals() - 1);
uniswapV2Router = _args.uniswapV2Router;
address __weth = _args.uniswapV2Router.WETH();
wrappedNativeAddress = __weth;
uniswapV2Pair = IUniswapV2Factory(_args.uniswapFactory).createPair(
address(this),
_args.mainLPToken
);
isPair[uniswapV2Pair] = true;
mainLPToken = _args.mainLPToken;
allShareHolders.push(address(0));
weth = __weth;
rewardToken = _args.sameTokenForRewards
? address(this)
: _args.mainLPToken;
isWethRewardToken =
!_args.sameTokenForRewards &&
__weth == _args.mainLPToken;
charityAddress = _args.charityAddress;
marketingAddress = _args.marketingAddress;
autoLiquidityAddress = _args.autoLiquidityAddress;
isExcludedFromFee[owner()] = true;
isExcludedFromFee[address(this)] = true;
isExcludedFromFee[charityAddress] = true;
isExcludedFromFee[marketingAddress] = true;
isExcludedFromFee[address(tempHolder)] = true;
transferTax = _args.transferTaxInfo;
buyTax = _args.buyTaxInfo;
sellTax = _args.sellTaxInfo;
excludedFromRewards[uniswapV2Pair] = true;
excludedFromRewards[address(this)] = true;
excludedFromRewards[address(_args.uniswapV2Router)] = true;
excludedFromRewards[address(tempHolder)] = true;
excludedFromRewards[owner()] = true;
_approve(address(this), address(uniswapV2Router), type(uint256).max);
IERC20(_args.mainLPToken).approve(
address(uniswapV2Router),
type(uint256).max
);
swapTaxes = _args.swapTaxes;
minShareForRewards = _args.minShareForRewards;
sameTokenForRewards = _args.sameTokenForRewards;
}
function transfer(
address recipient,
uint256 amount
) public virtual override returns (bool) {
_customTransfer(_msgSender(), recipient, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
require(
amount <= allowance(sender, _msgSender()),
"Transfer amount exceeds allowance"
);
_customTransfer(sender, recipient, amount);
unchecked {
_approve(
sender,
_msgSender(),
allowance(sender, _msgSender()) - amount
);
}
return true;
}
bool inSwap = false;
function _customTransfer(
address from,
address to,
uint256 amount
) internal virtual {
if (from == address(this) || to == address(this)) {
_transfer(from, to, amount);
return;
}
if (from != uniswapV2Pair && swapAndLiquifyActive) {
processReserves();
}
if (
!isTaxActive ||
inSwap ||
isExcludedFromFee[from] ||
isExcludedFromFee[to] ||
amount == 0
) {
_transfer(from, to, amount);
return;
}
TaxInfo memory taxInfo;
uint64 totalTax;
uint256 taxAmount;
if (!isPair[from] && !isPair[to]) {
taxInfo = transferTax;
} else if (isPair[from] && !isPair[to]) {
taxInfo = buyTax;
} else {
taxInfo = sellTax;
}
unchecked {
totalTax =
taxInfo.charity +
taxInfo.autoLiquidity +
taxInfo.marketing +
taxInfo.reflection;
taxAmount = (amount * totalTax) / PERCENT_DENOMINATOR;
}
if (taxAmount > 0) _transfer(from, address(this), taxAmount);
_transfer(from, to, amount - taxAmount);
if (totalTax == 0) return;
unchecked {
charityReserves += (taxAmount * taxInfo.charity) / totalTax;
autoLiquidityReserves +=
(taxAmount * taxInfo.autoLiquidity) /
totalTax;
marketingReserves += (taxAmount * taxInfo.marketing) / totalTax;
reflectionReserves += (taxAmount * taxInfo.reflection) / totalTax;
}
}
function setCharityAddress(address _charityAddress) external onlyOwner {
charityAddress = _charityAddress;
}
function setMarketingAddress(address _marketingAddress) external onlyOwner {
marketingAddress = _marketingAddress;
}
function setAutoLiquidityAddress(
address _autoLiquidityAddress
) external onlyOwner {
autoLiquidityAddress = _autoLiquidityAddress;
}
function setTransferTax(
uint64 _charity,
uint64 _autoLiquidity,
uint64 _marketing,
uint64 _holdersRewards
) external onlyOwner {
require(
_charity + _autoLiquidity + _marketing + _holdersRewards <= MAX_TAX,
"Transfer tax too high"
);
transferTax = TaxInfo(
_charity,
_autoLiquidity,
_marketing,
_holdersRewards
);
}
function setBuyTax(
uint64 _charity,
uint64 _autoLiquidity,
uint64 _marketing,
uint64 _holdersRewards
) external onlyOwner {
require(
_charity + _autoLiquidity + _marketing + _holdersRewards <= MAX_TAX,
"Buy tax too high"
);
buyTax = TaxInfo(_charity, _autoLiquidity, _marketing, _holdersRewards);
}
function setSellTax(
uint64 _charity,
uint64 _autoLiquidity,
uint64 _marketing,
uint64 _holdersRewards
) external onlyOwner {
require(
_charity + _autoLiquidity + _marketing + _holdersRewards <= MAX_TAX,
"Sell tax too high"
);
sellTax = TaxInfo(
_charity,
_autoLiquidity,
_marketing,
_holdersRewards
);
}
function setExcludedFromFee(
address account,
bool excluded
) external onlyOwner {
isExcludedFromFee[account] = excluded;
}
function setPair(address pair, bool value) external onlyOwner {
require(pair != uniswapV2Pair, "Cannot change pair");
isPair[pair] = value;
}
function setTaxActive(bool value) external onlyOwner {
isTaxActive = value;
}
function setSwapAndLiquifyActive(
bool _swapAndLiquifyActive
) external onlyOwner {
swapAndLiquifyActive = _swapAndLiquifyActive;
}
function setMinTokensBeforeSwap(
uint256 _minTokensBeforeSwap
) external onlyOwner {
minTokensBeforeSwap = _minTokensBeforeSwap;
}
function processReserves() public {
if (inSwap) return;
inSwap = true;
if (
charityReserves > minTokensBeforeSwap &&
charityAddress != address(0)
) {
if (swapTaxes) {
if (mainLPToken == wrappedNativeAddress) {
swapForETH(charityReserves, charityAddress);
} else {
swapForERC20(charityReserves, charityAddress);
}
} else _transfer(address(this), charityAddress, charityReserves);
delete charityReserves;
}
if (marketingReserves > minTokensBeforeSwap) {
if (swapTaxes) {
if (mainLPToken == wrappedNativeAddress) {
swapForETH(marketingReserves, marketingAddress);
} else {
swapForERC20(marketingReserves, marketingAddress);
}
} else
_transfer(address(this), marketingAddress, marketingReserves);
delete marketingReserves;
}
if (reflectionReserves > minTokensBeforeSwap && !sameTokenForRewards) {
if (mainLPToken == wrappedNativeAddress) {
uint256 initialBalance = address(this).balance;
swapForETH(reflectionReserves, address(this));
uint256 balanceAfter = address(this).balance - initialBalance;
_updateGlobalShares(balanceAfter);
} else {
swapForERC20(reflectionReserves, address(tempHolder));
uint256 balanceAfter = IERC20(mainLPToken).balanceOf(
address(tempHolder)
);
tempHolder.transfer(mainLPToken, address(this), balanceAfter);
_updateGlobalShares(balanceAfter);
}
delete reflectionReserves;
} else if (sameTokenForRewards) {
_updateGlobalShares(reflectionReserves);
delete reflectionReserves;
}
if (
autoLiquidityReserves > minTokensBeforeSwap &&
autoLiquidityAddress != address(0)
) {
autoLiquidityReserves = swapAndLiquify(autoLiquidityReserves);
}
inSwap = false;
}
function swapAndLiquify(uint256 _amount) internal returns (uint256) {
uint256 half = _amount / 2;
uint256 otherHalf = _amount - half;
uint256 leftOver;
if (mainLPToken == wrappedNativeAddress) {
uint256 initialBalance = address(this).balance;
swapForETH(half, address(this));
uint256 newBalance = address(this).balance - initialBalance;
(uint amountToken, , ) = addLiquidityETH(otherHalf, newBalance);
leftOver = otherHalf - amountToken;
} else {
swapForERC20(half, address(tempHolder));
uint256 newBalance = IERC20(mainLPToken).balanceOf(
address(tempHolder)
);
tempHolder.transfer(mainLPToken, address(this), newBalance);
(uint amountToken, , ) = addLiquidityERC20(otherHalf, newBalance);
leftOver = otherHalf - amountToken;
}
return leftOver;
}
function addLiquidityETH(
uint256 _tokenAmount,
uint256 _NativeAmount
) private returns (uint, uint, uint) {
return
uniswapV2Router.addLiquidityETH{value: _NativeAmount}(
address(this),
_tokenAmount,
0,
0,
autoLiquidityAddress,
block.timestamp
);
}
function addLiquidityERC20(
uint256 _tokenAmount,
uint256 _counterPartAmount
) private returns (uint, uint, uint) {
return
uniswapV2Router.addLiquidity(
address(this),
mainLPToken,
_tokenAmount,
_counterPartAmount,
0,
0,
autoLiquidityAddress,
block.timestamp
);
}
function swapForETH(uint256 _amount, address _to) internal {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = wrappedNativeAddress;
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
_amount,
0,
path,
_to,
block.timestamp
);
}
function swapForERC20(uint256 _amount, address _to) internal {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = mainLPToken;
uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
_amount,
0,
path,
_to,
block.timestamp
);
}
receive() external payable {
require(msg.sender == address(uniswapV2Router), "Invalid sender");
}
function _afterTokenTransfer(
address from_,
address to_,
uint256
) internal virtual override {
_updateShare(from_);
_updateShare(to_);
if (!inSwap) _massProcess();
}
function _massProcess() internal {
if (autoDistribute)
batchProcessClaims(
gasleft() > maxAutoProcessGas
? maxAutoProcessGas
: (gasleft() * 80) / 100
);
}
function _updateShare(address wallet) internal {
if (!excludedFromRewards[wallet])
_setShare(
wallet,
balanceOf(wallet) > minShareForRewards ? balanceOf(wallet) : 0
);
}
function includeInRewards(
address shareHolderToBeIncluded_
) external onlyOwner {
require(
excludedFromRewards[shareHolderToBeIncluded_],
"HODLRewardsDistributor: not excluded"
);
_updateUserShares(
shareHolderToBeIncluded_,
balanceOf(shareHolderToBeIncluded_)
);
excludedFromRewards[shareHolderToBeIncluded_] = false;
emit IncludedInRewards(shareHolderToBeIncluded_);
}
function setProcessingGasLimit(uint256 maxAmount_) external onlyOwner {
maxAutoProcessGas = maxAmount_;
}
function setMinSharePerRewards(
uint256 _minSharePerRewards
) external onlyOwner {
minShareForRewards = _minSharePerRewards;
}
function setAutoDistribute(bool _autoDistribute) external onlyOwner {
autoDistribute = _autoDistribute;
}
function pending(
address sharholderAddress_
) public view returns (uint256 pendingAmount) {
ShareHolder storage user = shareHolders[sharholderAddress_];
pendingAmount = user.shares.mul(accPerShare).div(1e36).sub(
user.rewardDebt
);
}
function totalPending() public view returns (uint256) {
return accPerShare.mul(totalShares).div(1e36).sub(totalRewardsDebt);
}
function shareHolderInfo(
address shareHoldr_
) external view returns (ShareHolder memory) {
ShareHolder storage user = shareHolders[shareHoldr_];
return
ShareHolder(
user.shares,
user.rewardDebt,
user.claimed,
pending(shareHoldr_)
);
}
function holders() external view returns (uint256) {
return allShareHolders.length;
}
function _setShare(address sharholderAddress_, uint256 amount_) internal {
ShareHolder storage user = shareHolders[sharholderAddress_];
if (user.shares > 0) claimPending(sharholderAddress_);
_updateUserShares(sharholderAddress_, amount_);
}
function excludeFromRewards(
address shareHolderToBeExcluded_
) external onlyOwner {
_excludeFromRewards(shareHolderToBeExcluded_);
}
function _excludeFromRewards(address shareHolderToBeExcluded_) internal {
if (excludedFromRewards[shareHolderToBeExcluded_]) return;
uint256 amountPending = pending(shareHolderToBeExcluded_);
_updateUserShares(shareHolderToBeExcluded_, 0);
if (amountPending > 0) _updateGlobalShares(amountPending);
excludedFromRewards[shareHolderToBeExcluded_] = true;
emit ExcludedFromRewards(shareHolderToBeExcluded_);
}
function claimPending(address sharholderAddress_) public {
ShareHolder storage user = shareHolders[sharholderAddress_];
uint256 pendingAmount = user.shares.mul(accPerShare).div(1e36).sub(
user.rewardDebt
);
if (pendingAmount <= 0) return;
totalRewardsDebt = totalRewardsDebt.sub(user.rewardDebt);
user.rewardDebt = user.shares.mul(accPerShare).div(1e36);
totalRewardsDebt = totalRewardsDebt.add(user.rewardDebt);
bool sent;
if (isWethRewardToken) {
(sent, ) = payable(sharholderAddress_).call{value: pendingAmount}(
""
);
if (!sent) {
_updateGlobalShares(pendingAmount);
}
} else {
IERC20(rewardToken).transfer(sharholderAddress_, pendingAmount);
sent = true;
}
if (sent) {
emit Claimed(sharholderAddress_, pendingAmount);
user.claimed = user.claimed.add(pendingAmount);
totalClaimed = totalClaimed.add(pendingAmount);
}
}
bool private _inBatchProcess;
function batchProcessClaims(uint256 gas) public {
if (gasleft() < gas || _inBatchProcess) return;
_inBatchProcess = true;
uint256 gasUsed = 0;
uint256 gasLeft = gasleft();
uint256 iterations = 1;
uint256 index = _lastProccessedIndex;
while (gasUsed < gas && iterations < allShareHolders.length) {
claimPending(allShareHolders[index]);
gasUsed = gasUsed.add(gasLeft.sub(gasleft()));
gasLeft = gasleft();
index = _incrementLastProccessed(index);
iterations++;
}
_lastProccessedIndex = index;
_inBatchProcess = false;
}
uint256 reserved = 0;
function _updateGlobalShares(uint256 amount_) internal {
if (totalShares == 0) {
reserved = reserved.add(amount_);
return;
}
accPerShare = accPerShare.add(amount_.mul(1e36).div(totalShares)).add(
reserved.mul(1e36).div(totalShares)
);
reserved = 0;
emit RewardsAdded(amount_);
}
function updateGlobalShares(uint256 amount_) external onlyOwner {
_updateGlobalShares(amount_);
}
function _updateUserShares(
address sharholderAddress_,
uint256 newAmount_
) internal {
ShareHolder storage user = shareHolders[sharholderAddress_];
totalShares = totalShares.sub(user.shares).add(newAmount_);
totalRewardsDebt = totalRewardsDebt.sub(user.rewardDebt);
user.shares = newAmount_;
user.rewardDebt = user.shares.mul(accPerShare).div(1e36);
totalRewardsDebt = totalRewardsDebt.add(user.rewardDebt);
if (user.shares > 0 && indexOfShareHolders[sharholderAddress_] == 0) {
allShareHolders.push(sharholderAddress_);
indexOfShareHolders[sharholderAddress_] =
allShareHolders.length -
1;
} else if (
user.shares == 0 && indexOfShareHolders[sharholderAddress_] != 0
) {
uint256 index = indexOfShareHolders[sharholderAddress_];
allShareHolders[index] = allShareHolders[
allShareHolders.length - 1
];
indexOfShareHolders[
allShareHolders[allShareHolders.length - 1]
] = index;
allShareHolders.pop();
indexOfShareHolders[sharholderAddress_] = 0;
}
emit ShareUpdated(sharholderAddress_, newAmount_);
}
function _incrementLastProccessed(
uint256 _index
) internal view returns (uint256) {
_index++;
if (_index >= allShareHolders.length) _index = 1;
return _index;
}
}
abstract contract DividendsTokenCustomVotes is ERC20VotesDecimals, Ownable {
using SafeMath for uint256;
using SafeERC20 for IERC20;
uint256 public minShareForRewards;
uint256 public maxAutoProcessGas = 500000;
bool public autoDistribute = true;
uint256 public accPerShare;
uint256 public totalShares;
uint256 public totalClaimed;
uint256 public totalRewardsDebt;
mapping(address => ShareHolder) shareHolders;
address[] public allShareHolders;
mapping(address => uint256) public indexOfShareHolders;
uint256 private _lastProccessedIndex = 1;
mapping(address => bool) public excludedFromRewards;
event Claimed(address indexed claimer, uint256 indexed amount);
event RewardsAdded(uint256 indexed amount);
event ShareUpdated(
address indexed shareHolder,
uint256 indexed sharesAmount
);
event IncludedInRewards(address indexed shareHolder);
event ExcludedFromRewards(address indexed shareHolder);
address public immutable weth;
address public immutable rewardToken;
bool immutable isWethRewardToken;
uint256 public constant PERCENT_DENOMINATOR = 1000;
uint256 public constant MAX_TAX = 200;
IUniswapV2Router02 public immutable uniswapV2Router;
address public immutable uniswapV2Pair;
address public immutable wrappedNativeAddress;
address public immutable mainLPToken;
ERC20TempHolder public immutable tempHolder = new ERC20TempHolder();
bool public immutable sameTokenForRewards;
address public charityAddress;
address public marketingAddress;
address public autoLiquidityAddress;
TaxInfo public transferTax;
TaxInfo public buyTax;
TaxInfo public sellTax;
bool public isTaxActive;
bool public swapAndLiquifyActive = true;
uint256 public minTokensBeforeSwap;
mapping(address => bool) public isExcludedFromFee;
mapping(address => bool) public isPair;
uint256 public charityReserves;
uint256 public marketingReserves;
uint256 public autoLiquidityReserves;
uint256 public reflectionReserves;
bool public swapTaxes;
function setSwapTaxes(bool _swapTaxes) external onlyOwner {
swapTaxes = _swapTaxes;
}
constructor(DividendConstructorArgs memory _args) {
minTokensBeforeSwap = (1 * 10) ** (decimals() - 1);
uniswapV2Router = _args.uniswapV2Router;
address __weth = _args.uniswapV2Router.WETH();
wrappedNativeAddress = __weth;
uniswapV2Pair = IUniswapV2Factory(_args.uniswapFactory).createPair(
address(this),
_args.mainLPToken
);
isPair[uniswapV2Pair] = true;
mainLPToken = _args.mainLPToken;
allShareHolders.push(address(0));
weth = __weth;
rewardToken = _args.sameTokenForRewards
? address(this)
: _args.mainLPToken;
isWethRewardToken =
!_args.sameTokenForRewards &&
__weth == _args.mainLPToken;
charityAddress = _args.charityAddress;
marketingAddress = _args.marketingAddress;
autoLiquidityAddress = _args.autoLiquidityAddress;
isExcludedFromFee[owner()] = true;
isExcludedFromFee[address(this)] = true;
isExcludedFromFee[charityAddress] = true;
isExcludedFromFee[marketingAddress] = true;
isExcludedFromFee[address(tempHolder)] = true;
transferTax = _args.transferTaxInfo;
buyTax = _args.buyTaxInfo;
sellTax = _args.sellTaxInfo;
excludedFromRewards[uniswapV2Pair] = true;
excludedFromRewards[address(this)] = true;
excludedFromRewards[address(_args.uniswapV2Router)] = true;
excludedFromRewards[address(tempHolder)] = true;
excludedFromRewards[owner()] = true;
_approve(address(this), address(uniswapV2Router), type(uint256).max);
IERC20(_args.mainLPToken).approve(
address(uniswapV2Router),
type(uint256).max
);
swapTaxes = _args.swapTaxes;
minShareForRewards = _args.minShareForRewards;
sameTokenForRewards = _args.sameTokenForRewards;
}
function transfer(
address recipient,
uint256 amount
) public virtual override returns (bool) {
_customTransfer(_msgSender(), recipient, amount);
return true;
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override returns (bool) {
require(
amount <= allowance(sender, _msgSender()),
"Transfer amount exceeds allowance"
);
_customTransfer(sender, recipient, amount);
unchecked {
_approve(
sender,
_msgSender(),
allowance(sender, _msgSender()) - amount
);
}
return true;
}
bool inSwap = false;
function _customTransfer(
address from,
address to,
uint256 amount
) internal virtual {
if (from == address(this) || to == address(this)) {
_transfer(from, to, amount);
return;
}
if (from != uniswapV2Pair && swapAndLiquifyActive) {
processReserves();
}
if (
!isTaxActive ||
inSwap ||
isExcludedFromFee[from] ||
isExcludedFromFee[to] ||
amount == 0
) {
_transfer(from, to, amount);
return;
}
TaxInfo memory taxInfo;
uint64 totalTax;
uint256 taxAmount;
if (!isPair[from] && !isPair[to]) {
taxInfo = transferTax;
} else if (isPair[from] && !isPair[to]) {
taxInfo = buyTax;
} else {
taxInfo = sellTax;
}
unchecked {
totalTax =
taxInfo.charity +
taxInfo.autoLiquidity +
taxInfo.marketing +
taxInfo.reflection;
taxAmount = (amount * totalTax) / PERCENT_DENOMINATOR;
}
if (taxAmount > 0) _transfer(from, address(this), taxAmount);
_transfer(from, to, amount - taxAmount);
if (totalTax == 0) return;
unchecked {
charityReserves += (taxAmount * taxInfo.charity) / totalTax;
autoLiquidityReserves +=
(taxAmount * taxInfo.autoLiquidity) /
totalTax;
marketingReserves += (taxAmount * taxInfo.marketing) / totalTax;
reflectionReserves += (taxAmount * taxInfo.reflection) / totalTax;
}
}
function setCharityAddress(address _charityAddress) external onlyOwner {
charityAddress = _charityAddress;
}
function setMarketingAddress(address _marketingAddress) external onlyOwner {
marketingAddress = _marketingAddress;
}
function setAutoLiquidityAddress(
address _autoLiquidityAddress
) external onlyOwner {
autoLiquidityAddress = _autoLiquidityAddress;
}
function setTransferTax(
uint64 _charity,
uint64 _autoLiquidity,
uint64 _marketing,
uint64 _holdersRewards
) external onlyOwner {
require(
_charity + _autoLiquidity + _marketing + _holdersRewards <= MAX_TAX,
"Transfer tax too high"
);
transferTax = TaxInfo(
_charity,
_autoLiquidity,
_marketing,
_holdersRewards
);
}
function setBuyTax(
uint64 _charity,
uint64 _autoLiquidity,
uint64 _marketing,
uint64 _holdersRewards
) external onlyOwner {
require(
_charity + _autoLiquidity + _marketing + _holdersRewards <= MAX_TAX,
"Buy tax too high"
);
buyTax = TaxInfo(_charity, _autoLiquidity, _marketing, _holdersRewards);
}
function setSellTax(
uint64 _charity,
uint64 _autoLiquidity,
uint64 _marketing,
uint64 _holdersRewards
) external onlyOwner {
require(
_charity + _autoLiquidity + _marketing + _holdersRewards <= MAX_TAX,
"Sell tax too high"
);
sellTax = TaxInfo(
_charity,
_autoLiquidity,
_marketing,
_holdersRewards
);
}
function setExcludedFromFee(
address account,
bool excluded
) external onlyOwner {
isExcludedFromFee[account] = excluded;
}
function setPair(address pair, bool value) external onlyOwner {
require(pair != uniswapV2Pair, "Cannot change pair");
isPair[pair] = value;
}
function setTaxActive(bool value) external onlyOwner {
isTaxActive = value;
}
function setSwapAndLiquifyActive(
bool _swapAndLiquifyActive
) external onlyOwner {
swapAndLiquifyActive = _swapAndLiquifyActive;
}
function setMinTokensBeforeSwap(
uint256 _minTokensBeforeSwap
) external onlyOwner {
minTokensBeforeSwap = _minTokensBeforeSwap;
}
function processReserves() public {
if (inSwap) return;
inSwap = true;
if (
charityReserves > minTokensBeforeSwap &&
charityAddress != address(0)
) {
if (swapTaxes) {
if (mainLPToken == wrappedNativeAddress) {
swapForETH(charityReserves, charityAddress);
} else {
swapForERC20(charityReserves, charityAddress);
}
} else _transfer(address(this), charityAddress, charityReserves);
delete charityReserves;
}
if (marketingReserves > minTokensBeforeSwap) {
if (swapTaxes) {
if (mainLPToken == wrappedNativeAddress) {
swapForETH(marketingReserves, marketingAddress);
} else {
swapForERC20(marketingReserves, marketingAddress);
}
} else
_transfer(address(this), marketingAddress, marketingReserves);
delete marketingReserves;
}
if (reflectionReserves > minTokensBeforeSwap && !sameTokenForRewards) {
if (mainLPToken == wrappedNativeAddress) {
uint256 initialBalance = address(this).balance;
swapForETH(reflectionReserves, address(this));
uint256 balanceAfter = address(this).balance - initialBalance;
_updateGlobalShares(balanceAfter);
} else {
swapForERC20(reflectionReserves, address(tempHolder));
uint256 balanceAfter = IERC20(mainLPToken).balanceOf(
address(tempHolder)
);
tempHolder.transfer(mainLPToken, address(this), balanceAfter);
_updateGlobalShares(balanceAfter);
}
delete reflectionReserves;
} else if (sameTokenForRewards) {
_updateGlobalShares(reflectionReserves);
delete reflectionReserves;
}
if (
autoLiquidityReserves / 2 > minTokensBeforeSwap &&
autoLiquidityAddress != address(0)
) {
autoLiquidityReserves = swapAndLiquify(autoLiquidityReserves);
}
inSwap = false;
}
function swapAndLiquify(uint256 _amount) internal returns (uint256) {
uint256 half = _amount / 2;
uint256 otherHalf = _amount - half;
uint256 leftOver;
if (mainLPToken == wrappedNativeAddress) {
uint256 initialBalance = address(this).balance;
swapForETH(half, address(this));
uint256 newBalance = address(this).balance - initialBalance;
(uint amountToken, , ) = addLiquidityETH(otherHalf, newBalance);
leftOver = otherHalf - amountToken;
} else {
swapForERC20(half, address(tempHolder));
uint256 newBalance = IERC20(mainLPToken).balanceOf(
address(tempHolder)
);
tempHolder.transfer(mainLPToken, address(this), newBalance);
(uint amountToken, , ) = addLiquidityERC20(otherHalf, newBalance);
leftOver = otherHalf - amountToken;
}
return leftOver;
}
function addLiquidityETH(
uint256 _tokenAmount,
uint256 _NativeAmount
) private returns (uint, uint, uint) {
return
uniswapV2Router.addLiquidityETH{value: _NativeAmount}(
address(this),
_tokenAmount,
0,
0,
autoLiquidityAddress,
block.timestamp
);
}
function addLiquidityERC20(
uint256 _tokenAmount,
uint256 _counterPartAmount
) private returns (uint, uint, uint) {
return
uniswapV2Router.addLiquidity(
address(this),
mainLPToken,
_tokenAmount,
_counterPartAmount,
0,
0,
autoLiquidityAddress,
block.timestamp
);
}
function swapForETH(uint256 _amount, address _to) internal {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = wrappedNativeAddress;
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
_amount,
0,
path,
_to,
block.timestamp
);
}
function swapForERC20(uint256 _amount, address _to) internal {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = mainLPToken;
uniswapV2Router.swapExactTokensForTokensSupportingFeeOnTransferTokens(
_amount,
0,
path,
_to,
block.timestamp
);
}
receive() external payable {
require(msg.sender == address(uniswapV2Router), "Invalid sender");
}
function _afterTokenTransfer(
address from_,
address to_,
uint256
) internal virtual override {
_updateShare(from_);
_updateShare(to_);
if (!inSwap) _massProcess();
}
function _massProcess() internal {
if (autoDistribute)
batchProcessClaims(
gasleft() > maxAutoProcessGas
? maxAutoProcessGas
: (gasleft() * 80) / 100
);
}
function _updateShare(address wallet) internal {
if (!excludedFromRewards[wallet])
_setShare(
wallet,
balanceOf(wallet) > minShareForRewards ? balanceOf(wallet) : 0
);
}
function includeInRewards(
address shareHolderToBeIncluded_
) external onlyOwner {
require(
excludedFromRewards[shareHolderToBeIncluded_],
"HODLRewardsDistributor: not excluded"
);
_updateUserShares(
shareHolderToBeIncluded_,
balanceOf(shareHolderToBeIncluded_)
);
excludedFromRewards[shareHolderToBeIncluded_] = false;
emit IncludedInRewards(shareHolderToBeIncluded_);
}
function setProcessingGasLimit(uint256 maxAmount_) external onlyOwner {
maxAutoProcessGas = maxAmount_;
}
function setMinSharePerRewards(
uint256 _minSharePerRewards
) external onlyOwner {
minShareForRewards = _minSharePerRewards;
}
function setAutoDistribute(bool _autoDistribute) external onlyOwner {
autoDistribute = _autoDistribute;
}
function pending(
address sharholderAddress_
) public view returns (uint256 pendingAmount) {
ShareHolder storage user = shareHolders[sharholderAddress_];
pendingAmount = user.shares.mul(accPerShare).div(1e36).sub(
user.rewardDebt
);
}
function totalPending() public view returns (uint256) {
return accPerShare.mul(totalShares).div(1e36).sub(totalRewardsDebt);
}
function shareHolderInfo(
address shareHoldr_
) external view returns (ShareHolder memory) {
ShareHolder storage user = shareHolders[shareHoldr_];
return
ShareHolder(
user.shares,
user.rewardDebt,
user.claimed,
pending(shareHoldr_)
);
}
function holders() external view returns (uint256) {
return allShareHolders.length;
}
function _setShare(address sharholderAddress_, uint256 amount_) internal {
ShareHolder storage user = shareHolders[sharholderAddress_];
if (user.shares > 0) claimPending(sharholderAddress_);
_updateUserShares(sharholderAddress_, amount_);
}
function excludeFromRewards(
address shareHolderToBeExcluded_
) external onlyOwner {
_excludeFromRewards(shareHolderToBeExcluded_);
}
function _excludeFromRewards(address shareHolderToBeExcluded_) internal {
if (excludedFromRewards[shareHolderToBeExcluded_]) return;
uint256 amountPending = pending(shareHolderToBeExcluded_);
_updateUserShares(shareHolderToBeExcluded_, 0);
if (amountPending > 0) _updateGlobalShares(amountPending);
excludedFromRewards[shareHolderToBeExcluded_] = true;
emit ExcludedFromRewards(shareHolderToBeExcluded_);
}
function claimPending(address sharholderAddress_) public {
ShareHolder storage user = shareHolders[sharholderAddress_];
uint256 pendingAmount = user.shares.mul(accPerShare).div(1e36).sub(
user.rewardDebt
);
if (pendingAmount <= 0) return;
totalRewardsDebt = totalRewardsDebt.sub(user.rewardDebt);
user.rewardDebt = user.shares.mul(accPerShare).div(1e36);
totalRewardsDebt = totalRewardsDebt.add(user.rewardDebt);
bool sent;
if (isWethRewardToken) {
(sent, ) = payable(sharholderAddress_).call{value: pendingAmount}(
""
);
if (!sent) {
_updateGlobalShares(pendingAmount);
}
} else {
IERC20(rewardToken).transfer(sharholderAddress_, pendingAmount);
sent = true;
}
if (sent) {
emit Claimed(sharholderAddress_, pendingAmount);
user.claimed = user.claimed.add(pendingAmount);
totalClaimed = totalClaimed.add(pendingAmount);
}
}
bool private _inBatchProcess;
function batchProcessClaims(uint256 gas) public {
if (gasleft() < gas || _inBatchProcess) return;
_inBatchProcess = true;
uint256 gasUsed = 0;
uint256 gasLeft = gasleft();
uint256 iterations = 1;
uint256 index = _lastProccessedIndex;
while (gasUsed < gas && iterations < allShareHolders.length) {
claimPending(allShareHolders[index]);
gasUsed = gasUsed.add(gasLeft.sub(gasleft()));
gasLeft = gasleft();
index = _incrementLastProccessed(index);
iterations++;
}
_lastProccessedIndex = index;
_inBatchProcess = false;
}
uint256 reserved = 0;
function _updateGlobalShares(uint256 amount_) internal {
if (totalShares == 0) {
reserved = reserved.add(amount_);
return;
}
accPerShare = accPerShare.add(amount_.mul(1e36).div(totalShares)).add(
reserved.mul(1e36).div(totalShares)
);
reserved = 0;
emit RewardsAdded(amount_);
}
function updateGlobalShares(uint256 amount_) external onlyOwner {
_updateGlobalShares(amount_);
}
function _updateUserShares(
address sharholderAddress_,
uint256 newAmount_
) internal {
ShareHolder storage user = shareHolders[sharholderAddress_];
totalShares = totalShares.sub(user.shares).add(newAmount_);
totalRewardsDebt = totalRewardsDebt.sub(user.rewardDebt);
user.shares = newAmount_;
user.rewardDebt = user.shares.mul(accPerShare).div(1e36);
totalRewardsDebt = totalRewardsDebt.add(user.rewardDebt);
if (user.shares > 0 && indexOfShareHolders[sharholderAddress_] == 0) {
allShareHolders.push(sharholderAddress_);
indexOfShareHolders[sharholderAddress_] =
allShareHolders.length -
1;
} else if (
user.shares == 0 && indexOfShareHolders[sharholderAddress_] != 0
) {
uint256 index = indexOfShareHolders[sharholderAddress_];
allShareHolders[index] = allShareHolders[
allShareHolders.length - 1
];
indexOfShareHolders[
allShareHolders[allShareHolders.length - 1]
] = index;
allShareHolders.pop();
indexOfShareHolders[sharholderAddress_] = 0;
}
emit ShareUpdated(sharholderAddress_, newAmount_);
}
function _incrementLastProccessed(
uint256 _index
) internal view returns (uint256) {
_index++;
if (_index >= allShareHolders.length) _index = 1;
return _index;
}
}
abstract contract WhiteList is Ownable {
mapping(address => bool) private _whiteList;
event AddedToWhiteList(address indexed account);
event RemovedFromWhiteList(address indexed account);
modifier onlyWhiteListed() {
require(
_whiteList[_msgSender()],
"WhiteList: account is not whitelisted"
);
_;
}
function _addToWhiteList(address account) internal {
_whiteList[account] = true;
emit AddedToWhiteList(account);
}
function _removeFromWhiteList(address account) internal {
_whiteList[account] = false;
emit RemovedFromWhiteList(account);
}
function addToWhiteList(address account) external onlyOwner {
_addToWhiteList(account);
}
function removeFromWhiteList(address account) external onlyOwner {
_removeFromWhiteList(account);
}
function isWhitelisted(address account) public view returns (bool) {
return _whiteList[account];
}
}
abstract contract ERC20LaunchMode is ERC20Decimals, WhiteList {
bool private _launchModeEnabled = true;
modifier onlyAfterLaunch(address from, address to) {
require(
!_launchModeEnabled ||
from == address(0) ||
to == address(0) ||
isWhitelisted(from) ||
isWhitelisted(to) ||
from == owner() ||
to == owner(),
"ERC20LaunchMode: Launch mode is enabled"
);
_;
}
function disableLaunchMode() external onlyOwner {
_launchModeEnabled = false;
}
function isInLaunchMode() public view returns (bool) {
return _launchModeEnabled;
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override onlyAfterLaunch(from, to) {}
}
abstract contract ERC20LaunchModeVotes is ERC20VotesDecimals, WhiteList {
bool private _launchModeEnabled = true;
modifier onlyAfterLaunch(address from, address to) {
require(
!_launchModeEnabled ||
from == address(0) ||
to == address(0) ||
isWhitelisted(from) ||
isWhitelisted(to) ||
from == owner() ||
to == owner(),
"ERC20LaunchMode: Launch mode is enabled"
);
_;
}
function disableLaunchMode() external onlyOwner {
_launchModeEnabled = false;
}
function isInLaunchMode() public view returns (bool) {
return _launchModeEnabled;
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override onlyAfterLaunch(from, to) {}
}
contract DividendsTokenCustomLaunch is ERC20LaunchMode, DividendsTokenCustom {
constructor(
uint256 _initialSupply,
uint8 _decimals,
string memory _name,
string memory _symbol,
address _owner,
DividendConstructorArgs memory _args
)
ERC20(_name, _symbol)
ERC20Decimals(_decimals)
Ownable(_owner)
DividendsTokenCustom(_args)
{
_mint(_owner, _initialSupply);
}
function transfer(
address recipient,
uint256 amount
) public virtual override(ERC20, DividendsTokenCustom) returns (bool) {
return DividendsTokenCustom.transfer(recipient, amount);
}
function transferFrom(
address sender,
address recipient,
uint256 amount
) public virtual override(ERC20, DividendsTokenCustom) returns (bool) {
return DividendsTokenCustom.transferFrom(sender, recipient, amount);
}
function _afterTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override(DividendsTokenCustom, ERC20) {
ERC20._afterTokenTransfer(from, to, amount);
DividendsTokenCustom._afterTokenTransfer(from, to, amount);
}
function _beforeTokenTransfer(
address from,
address to,
uint256 amount
) internal virtual override(ERC20LaunchMode, ERC20) {
ERC20._beforeTokenTransfer(from, to, amount);
ERC20LaunchMode._beforeTokenTransfer(from, to, amount);
}
}
