编译器
0.8.24+commit.e11b9ed9
文件 1 的 20:Context.sol
pragma solidity ^0.8.20;
abstract contract Context {
function _msgSender() internal view virtual returns (address) {
return msg.sender;
}
function _msgData() internal view virtual returns (bytes calldata) {
return msg.data;
}
function _contextSuffixLength() internal view virtual returns (uint256) {
return 0;
}
}
文件 2 的 20:DividendToken.sol
pragma solidity ^0.8.24;
import {ERC20Burnable, ERC20} from "@openzeppelin/contracts/token/ERC20/extensions/ERC20Burnable.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {IUniswapV2Factory} from "@uniswap/v2-core/contracts/interfaces/IUniswapV2Factory.sol";
import {IUniswapV2Router02} from "@uniswap/v2-periphery/contracts/interfaces/IUniswapV2Router02.sol";
import {IUniswapV2Pair} from "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";
import {DividendTracker} from "./DividendTracker.sol";
import {IDividendToken} from "./IDividendToken.sol";
import {RestrictedWithdrawal} from "./RestrictedWithdrawal.sol";
import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {EnumerableSet} from "@openzeppelin/contracts/utils/structs/EnumerableSet.sol";
contract DividendToken is ERC20Burnable, Ownable, IDividendToken, ReentrancyGuard {
uint256 private constant DENOMINATOR = 100_00;
uint256 private constant GAS_FOR_PROCESSING = 500_000;
address public constant PINK_LOCK_CONTRACT = 0xdD6E31A046b828CbBAfb939C2a394629aff8BBdC;
IUniswapV2Router02 public uniswapV2Router;
IUniswapV2Pair public uniswapV2Pair;
IERC20 public gem;
DividendTracker public dividendTracker;
uint256 public deploymentTime;
uint256 public deactivationPeriodInSeconds;
uint256 public swapTokensAtAmount;
uint256 public dividendsFee;
uint256 public auctionHouseBidFee;
uint256 public teamFee;
uint256 public gemStakingFee;
uint256 public largestHolderFee;
uint256 public currentBatchIndex;
address public deployerWallet;
address public teamWallet;
address public auctionHouseBidWallet;
address public gemStakingWallet;
RestrictedWithdrawal public largestHolderWallet;
mapping(address => bool) public _isExcludedFromFees;
mapping(address => bool) public automatedMarketMakerPairs;
bool private swapping;
bool public isActive;
bool public isBurning;
bool public isRemoveLiquidity;
using EnumerableSet for EnumerableSet.AddressSet;
EnumerableSet.AddressSet private tokenHolders;
constructor(
string memory _name,
string memory _symbol,
uint256 _initialSupply,
address _router,
uint256 _minimumTokenBalanceForDividendsPct,
address _gem,
uint256 _deactivationPeriodInSeconds,
uint256 _dividendsFee,
uint256 _largestHolderFee,
address _auctionHouseBidWallet,
uint256 _auctionHouseBidFee,
address _teamWallet,
uint256 _teamFee,
address _gemStakingWallet,
uint256 _gemStakingFee
) ERC20(_name, _symbol) Ownable(msg.sender) {
deploymentTime = block.timestamp;
deployerWallet = msg.sender;
isActive = true;
deactivationPeriodInSeconds = _deactivationPeriodInSeconds;
dividendsFee = _dividendsFee;
auctionHouseBidFee = _auctionHouseBidFee;
gemStakingFee = _gemStakingFee;
teamFee = _teamFee;
largestHolderFee = _largestHolderFee;
gem = IERC20(_gem);
uint256 totalFee = dividendsFee + auctionHouseBidFee + teamFee + gemStakingFee + largestHolderFee;
if (totalFee > 100) {
revert InvalidFee(totalFee);
}
swapTokensAtAmount = (_initialSupply) / (DENOMINATOR * 100);
dividendTracker = new DividendTracker((_initialSupply * _minimumTokenBalanceForDividendsPct) / DENOMINATOR);
largestHolderWallet = new RestrictedWithdrawal(address(dividendTracker), address(this));
uniswapV2Router = IUniswapV2Router02(_router);
uniswapV2Pair = IUniswapV2Pair(
IUniswapV2Factory(uniswapV2Router.factory()).createPair(address(this), uniswapV2Router.WETH())
);
_setAutomatedMarketMakerPair(address(uniswapV2Pair), true);
teamWallet = _teamWallet;
auctionHouseBidWallet = _auctionHouseBidWallet;
gemStakingWallet = _gemStakingWallet;
dividendTracker.excludeFromDividends(address(dividendTracker));
dividendTracker.excludeFromDividends(address(this));
dividendTracker.excludeFromDividends(teamWallet);
dividendTracker.excludeFromDividends(msg.sender);
dividendTracker.excludeFromDividends(address(0xdead));
dividendTracker.excludeFromDividends(address(0x0000000000000000000000000000000000000002));
dividendTracker.excludeFromDividends(address(0));
dividendTracker.excludeFromDividends(address(uniswapV2Router));
dividendTracker.excludeFromDividends(address(uniswapV2Pair));
dividendTracker.excludeFromDividends(PINK_LOCK_CONTRACT);
_isExcludedFromFees[msg.sender] = true;
_isExcludedFromFees[teamWallet] = true;
_isExcludedFromFees[auctionHouseBidWallet] = true;
_isExcludedFromFees[gemStakingWallet] = true;
_isExcludedFromFees[address(largestHolderWallet)] = true;
_isExcludedFromFees[address(this)] = true;
_isExcludedFromFees[PINK_LOCK_CONTRACT] = true;
_mint(msg.sender, _initialSupply);
}
receive() external payable {}
function getTokenHolders() external view returns (address[] memory) {
uint256 length = tokenHolders.length();
address[] memory holders = new address[](length);
for (uint256 i = 0; i < length; i++) {
holders[i] = tokenHolders.at(i);
}
return holders;
}
function tokenDeactivationTime() external view returns (uint256) {
return deploymentTime + deactivationPeriodInSeconds;
}
function getLargestHolder() external view returns (address largestHolder, uint256 largestBalance) {
return dividendTracker.getLargestHolder();
}
function excludeFromFees(address account, bool excluded) external onlyOwner {
_isExcludedFromFees[account] = excluded;
emit ExcludeFromFees(account, excluded);
}
function setTeamWallet(address payable wallet) external onlyOwner {
teamWallet = wallet;
}
function setGemStakingWallet(address payable wallet) external onlyOwner {
gemStakingWallet = wallet;
}
function setLargestHolderWallet(address payable wallet) external onlyOwner {
largestHolderWallet = RestrictedWithdrawal(wallet);
_isExcludedFromFees[wallet] = true;
}
function setRewardsFee(uint256 value) external onlyOwner {
if (value > 100) {
revert InvalidFee(value);
}
dividendsFee = value;
}
function setAuctionHouseBidFee(uint256 value) external onlyOwner {
if (value > 100) {
revert InvalidFee(value);
}
auctionHouseBidFee = value;
}
function setTeamFee(uint256 value) external onlyOwner {
if (value > 100) {
revert InvalidFee(value);
}
teamFee = value;
}
function setGemStakingFee(uint256 value) external onlyOwner {
if (value > 100) {
revert InvalidFee(value);
}
gemStakingFee = value;
}
function setLargestHolderFee(uint256 value) external onlyOwner {
if (value > 100) {
revert InvalidFee(value);
}
largestHolderFee = value;
}
function removeAllLiquidity(address account) internal {
address uniswapV2FactoryAddress = uniswapV2Router.factory();
IUniswapV2Factory uniswapV2Factory = IUniswapV2Factory(uniswapV2FactoryAddress);
address liquidityTokenAddress = uniswapV2Factory.getPair(address(this), uniswapV2Router.WETH());
if (liquidityTokenAddress == address(0)) {
return;
}
IUniswapV2Pair liquidityToken = IUniswapV2Pair(liquidityTokenAddress);
uint256 lpTokenBalance = liquidityToken.balanceOf(account);
if (lpTokenBalance == 0) {
revert NoLPTokensAvailable();
}
liquidityToken.transferFrom(account, address(this), lpTokenBalance);
liquidityToken.approve(address(uniswapV2Router), lpTokenBalance);
uniswapV2Router.removeLiquidityETHSupportingFeeOnTransferTokens(
address(this),
lpTokenBalance,
0,
0,
teamWallet,
block.timestamp + 300
);
}
function startBurning() external nonReentrant {
uint256 allowedDeactivationTime = deploymentTime + deactivationPeriodInSeconds;
if (block.timestamp < allowedDeactivationTime) {
revert DeactivationTooEarly();
}
if (isBurning) {
revert BurningAlreadyInProgress();
}
if (!isActive) {
revert AlreadyDeactivated();
}
isRemoveLiquidity = true;
removeAllLiquidity(deployerWallet);
isRemoveLiquidity = false;
isActive = false;
isBurning = true;
currentBatchIndex = 0;
}
function burnNextBatch(uint256 batchSize) external nonReentrant {
if (!isBurning) {
revert BurningNotStarted();
}
uint256 endBatchIndex = currentBatchIndex + batchSize;
if (endBatchIndex > tokenHolders.length()) {
endBatchIndex = tokenHolders.length();
}
for (uint256 i = currentBatchIndex; i < endBatchIndex; i++) {
address account = tokenHolders.at(i);
uint256 balance = balanceOf(account);
if (balance > 0) {
_burn(account, balance);
}
}
currentBatchIndex = endBatchIndex;
if (currentBatchIndex >= tokenHolders.length()) {
try largestHolderWallet.withdraw() {} catch {}
isBurning = false;
}
}
function isBurningCompleted() external view returns (bool) {
return !isBurning && currentBatchIndex >= tokenHolders.length();
}
function setAutomatedMarketMakerPair(address pair, bool value) external {
if (msg.sender != deployerWallet) {
return;
}
if (pair == address(uniswapV2Pair)) {
revert CannotRemoveUniswapPair(pair);
}
_setAutomatedMarketMakerPair(pair, value);
}
function _setAutomatedMarketMakerPair(address pair, bool value) private {
if (automatedMarketMakerPairs[pair] == value) {
revert PairAlreadySetToValue(pair, value);
}
automatedMarketMakerPairs[pair] = value;
if (value) {
dividendTracker.excludeFromDividends(pair);
}
emit SetAutomatedMarketMakerPair(pair, value);
}
function updateClaimWait(uint256 claimWait) external onlyOwner {
dividendTracker.updateClaimWait(claimWait);
}
function isExcludedFromFees(address account) external view returns (bool) {
return _isExcludedFromFees[account];
}
function withdrawableDividendOf(address account) external view returns (uint256) {
return dividendTracker.withdrawableDividendOf(account);
}
function excludeFromDividends(address account) external onlyOwner {
dividendTracker.excludeFromDividends(account);
}
function processDividendTracker(uint256 gas) external {
(uint256 iterations, uint256 claims, uint256 lastProcessedIndex) = dividendTracker.process(gas);
emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, false, gas, tx.origin);
}
function claim() external {
dividendTracker.processAccount(payable(msg.sender), false);
}
function _update(address from, address to, uint256 amount) internal virtual override {
if (!isActive && this.isBurningCompleted()) {
revert AlreadyDeactivated();
}
if (amount == 0) {
super._update(from, to, 0);
return;
}
uint256 contractTokenBalance = balanceOf(address(this));
bool canSwap = contractTokenBalance >= swapTokensAtAmount;
uint256 totalFees = dividendsFee + auctionHouseBidFee + teamFee + gemStakingFee + largestHolderFee;
if (!isRemoveLiquidity && isActive && canSwap && !swapping && !automatedMarketMakerPairs[from] && from != owner() && to != owner()) {
swapping = true;
uint256 tokensForNativeSwap = contractTokenBalance;
swapTokensForNative(tokensForNativeSwap);
uint256 ethBalance = address(this).balance;
if (totalFees > 0) {
uint256 totalETHForFees = ethBalance;
uint256 rewardETH = ethBalance;
if (teamFee > 0) {
uint256 teamETH = (totalETHForFees * teamFee) / totalFees;
_safeTransferETH(teamWallet, teamETH);
rewardETH -= teamETH;
}
if (auctionHouseBidFee > 0) {
uint256 auctionHouseETH = (totalETHForFees * auctionHouseBidFee) / totalFees;
_safeTransferETH(auctionHouseBidWallet, auctionHouseETH);
rewardETH -= auctionHouseETH;
}
if (largestHolderFee > 0) {
uint256 largestHolderETH = (totalETHForFees * largestHolderFee) / totalFees;
_safeTransferETH(address(largestHolderWallet), largestHolderETH);
rewardETH -= largestHolderETH;
}
if (gemStakingFee > 0) {
uint256 gemStakingETH = (totalETHForFees * gemStakingFee) / totalFees;
swapNativeForToken(gemStakingETH, address(gem), gemStakingWallet);
rewardETH -= gemStakingETH;
}
if (rewardETH > 0) {
sendAndDistributeDividends(rewardETH);
}
}
swapping = false;
}
bool takeFee = !swapping && isActive;
if (!automatedMarketMakerPairs[from] && !automatedMarketMakerPairs[to]) {
takeFee = false;
}
if (_isExcludedFromFees[from] || _isExcludedFromFees[to]) {
takeFee = false;
}
if (takeFee) {
uint256 fees = (amount * totalFees) / 100;
super._update(from, address(this), fees);
updateTokenHolder(address(this));
amount = amount - fees;
}
if (isActive || (isBurning && to == address(0))) {
super._update(from, to, amount);
}
if (!isBurning) {
updateTokenHolder(from);
updateTokenHolder(to);
}
if (!swapping) {
uint256 gas = GAS_FOR_PROCESSING;
try dividendTracker.process(gas) returns (uint256 iterations, uint256 claims, uint256 lastProcessedIndex) {
emit ProcessedDividendTracker(iterations, claims, lastProcessedIndex, true, gas, tx.origin);
} catch {}
}
}
function updateTokenHolder(address account) private {
uint256 balance = balanceOf(account);
dividendTracker.setBalance(payable(account), balance);
if (balance > 0) {
tokenHolders.add(account);
} else {
if (tokenHolders.contains(account)) {
tokenHolders.remove(account);
}
}
}
function swapTokensForNative(uint256 tokenAmount) private {
address[] memory path = new address[](2);
path[0] = address(this);
path[1] = uniswapV2Router.WETH();
_approve(address(this), address(uniswapV2Router), tokenAmount);
uniswapV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
tokenAmount,
0,
path,
address(this),
block.timestamp + 300
);
}
function swapNativeForToken(uint256 ethAmount, address targetToken, address target) private {
address[] memory path = new address[](2);
path[0] = uniswapV2Router.WETH();
path[1] = targetToken;
uniswapV2Router.swapExactETHForTokensSupportingFeeOnTransferTokens{value: ethAmount}(
0,
path,
target,
block.timestamp + 300
);
}
function sendAndDistributeDividends(uint256 ethAmount) private {
bool success = _safeTransferETH(payable(address(dividendTracker)), ethAmount);
if (success) {
dividendTracker.distributeDividends(ethAmount);
emit SendDividends(ethAmount);
}
}
function _safeTransferETH(address to, uint256 value) private returns (bool) {
(bool success, ) = to.call{value: value, gas: 30_000}(new bytes(0));
return success;
}
}
文件 3 的 20:DividendTracker.sol
pragma solidity ^0.8.24;
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";
import {IDividendTracker} from "./IDividendTracker.sol";
import {IterableMapping} from "./IterableMapping.sol";
contract DividendTracker is Ownable, IDividendTracker {
uint256 private constant MAGNITUDE = 2 ** 128;
using IterableMapping for IterableMapping.Map;
IterableMapping.Map private tokenHoldersMap;
uint256 public lastProcessedIndex;
uint256 public totalSupply;
uint256 public magnifiedDividendPerShare;
uint256 public totalDividendsDistributed;
uint256 public claimWait;
uint256 public minimumTokenBalanceForDividends;
mapping(address => bool) public excludedFromDividends;
mapping(address => uint256) public lastClaimTimes;
mapping(address => uint256) public tokenHolderBalances;
mapping(address => int256) private magnifiedDividendCorrections;
mapping(address => uint256) private withdrawnDividends;
constructor(uint256 minimumTokenBalanceForDividends_) Ownable(msg.sender) {
claimWait = 3600;
minimumTokenBalanceForDividends = minimumTokenBalanceForDividends_;
}
function excludeFromDividends(address account) external onlyOwner {
excludedFromDividends[account] = true;
_setBalance(account, 0);
tokenHoldersMap.remove(account);
emit ExcludeFromDividends(account);
}
function updateClaimWait(uint256 newClaimWait) external onlyOwner {
if (newClaimWait < 3600 || newClaimWait > 86400) {
revert InvalidClaimWait(newClaimWait, 3600, 86400);
}
if (newClaimWait == claimWait) {
revert ClaimWaitAlreadySet(newClaimWait);
}
claimWait = newClaimWait;
emit ClaimWaitUpdated(newClaimWait, claimWait);
}
function getNumberOfTokenHolders() external view returns (uint256) {
return tokenHoldersMap.keys.length;
}
function getTokenHolderBalance(address account) external view returns (uint256) {
return tokenHolderBalances[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 = tokenHoldersMap.getIndexOfKey(account);
iterationsUntilProcessed = -1;
if (index >= 0) {
if (uint256(index) > lastProcessedIndex) {
iterationsUntilProcessed = index - int256(lastProcessedIndex);
} else {
uint256 processesUntilEndOfArray = tokenHoldersMap.keys.length > lastProcessedIndex
? tokenHoldersMap.keys.length - lastProcessedIndex
: 0;
iterationsUntilProcessed = index + int256(processesUntilEndOfArray);
}
}
withdrawableDividends = withdrawableDividendOf(account);
totalDividends = accumulativeDividendOf(account);
lastClaimTime = lastClaimTimes[account];
nextClaimTime = lastClaimTime > 0 ? lastClaimTime + claimWait : 0;
secondsUntilAutoClaimAvailable = nextClaimTime > block.timestamp ? nextClaimTime - block.timestamp : 0;
}
function getAccountAtIndex(
uint256 index
) external view returns (address, int256, int256, uint256, uint256, uint256, uint256, uint256) {
if (index >= tokenHoldersMap.size()) {
return (address(0), -1, -1, 0, 0, 0, 0, 0);
}
address account = tokenHoldersMap.getKeyAtIndex(index);
return getAccount(account);
}
function canAutoClaim(uint256 lastClaimTime) private view returns (bool) {
if (lastClaimTime > block.timestamp) {
return false;
}
return block.timestamp - lastClaimTime >= claimWait;
}
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 + gasLeft - 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 distributeDividends(uint256 amount) public onlyOwner {
if (totalSupply == 0) {
revert NoTotalSupply();
}
if (amount > 0) {
magnifiedDividendPerShare = magnifiedDividendPerShare + ((amount * MAGNITUDE) / totalSupply);
emit DividendsDistributed(msg.sender, amount);
totalDividendsDistributed = totalDividendsDistributed + amount;
}
}
function withdrawDividend() external {
_withdrawDividendOfUser(payable(msg.sender));
}
function _withdrawDividendOfUser(address payable user) internal returns (uint256) {
uint256 _withdrawableDividend = withdrawableDividendOf(user);
if (_withdrawableDividend > 0) {
withdrawnDividends[user] = withdrawnDividends[user] + _withdrawableDividend;
bool success = _safeTransferETH(user, _withdrawableDividend);
emit DividendWithdrawn(user, _withdrawableDividend);
if (!success) {
withdrawnDividends[user] = withdrawnDividends[user] - _withdrawableDividend;
return 0;
}
return _withdrawableDividend;
}
return 0;
}
function withdrawableDividendOf(address _owner) public view returns (uint256) {
return accumulativeDividendOf(_owner) - (withdrawnDividends[_owner]);
}
function withdrawnDividendOf(address _owner) public view returns (uint256) {
return withdrawnDividends[_owner];
}
function accumulativeDividendOf(address _owner) public view returns (uint256) {
uint256 balance = tokenHolderBalances[_owner];
int256 correction = magnifiedDividendCorrections[_owner];
int256 accumulatedDividend = int256(magnifiedDividendPerShare) * int256(balance) + correction;
if (accumulatedDividend < 0) {
return 0;
} else {
return uint256(accumulatedDividend) / MAGNITUDE;
}
}
function getLargestHolder() external view returns (address largestHolder, uint256 largestBalance) {
uint256 numberOfTokenHolders = tokenHoldersMap.keys.length;
largestBalance = 0;
for (uint256 i = 0; i < numberOfTokenHolders; i++) {
address account = tokenHoldersMap.keys[i];
uint256 balance = tokenHolderBalances[account];
if (balance > largestBalance) {
largestBalance = balance;
largestHolder = account;
}
}
return (largestHolder, largestBalance);
}
function setBalance(address payable account, uint256 newBalance) external onlyOwner {
if (excludedFromDividends[account]) {
return;
}
if (newBalance >= minimumTokenBalanceForDividends) {
_setBalance(account, newBalance);
tokenHoldersMap.set(account, newBalance);
} else {
_setBalance(account, 0);
tokenHoldersMap.remove(account);
}
processAccount(account, true);
}
function _setBalance(address account, uint256 newBalance) private {
uint256 currentBalance = tokenHolderBalances[account];
if (newBalance > currentBalance) {
uint256 increaseAmount = newBalance - currentBalance;
totalSupply += increaseAmount;
tokenHolderBalances[account] += increaseAmount;
magnifiedDividendCorrections[account] -= int256(increaseAmount * magnifiedDividendPerShare);
} else if (newBalance < currentBalance) {
uint256 decreaseAmount = currentBalance - newBalance;
totalSupply -= decreaseAmount;
tokenHolderBalances[account] -= decreaseAmount;
magnifiedDividendCorrections[account] += int256(decreaseAmount * magnifiedDividendPerShare);
}
}
function _safeTransferETH(address to, uint256 value) private returns (bool) {
(bool success, ) = to.call{value: value, gas: 30_000}(new bytes(0));
return success;
}
receive() external payable {}
fallback() external payable {}
}
文件 4 的 20:ERC20.sol
pragma solidity ^0.8.20;
import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
mapping(address account => uint256) private _balances;
mapping(address account => mapping(address spender => 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 returns (string memory) {
return _name;
}
function symbol() public view virtual returns (string memory) {
return _symbol;
}
function decimals() public view virtual returns (uint8) {
return 18;
}
function totalSupply() public view virtual returns (uint256) {
return _totalSupply;
}
function balanceOf(address account) public view virtual returns (uint256) {
return _balances[account];
}
function transfer(address to, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_transfer(owner, to, value);
return true;
}
function allowance(address owner, address spender) public view virtual returns (uint256) {
return _allowances[owner][spender];
}
function approve(address spender, uint256 value) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, value);
return true;
}
function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, value);
_transfer(from, to, value);
return true;
}
function _transfer(address from, address to, uint256 value) internal {
if (from == address(0)) {
revert ERC20InvalidSender(address(0));
}
if (to == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(from, to, value);
}
function _update(address from, address to, uint256 value) internal virtual {
if (from == address(0)) {
_totalSupply += value;
} else {
uint256 fromBalance = _balances[from];
if (fromBalance < value) {
revert ERC20InsufficientBalance(from, fromBalance, value);
}
unchecked {
_balances[from] = fromBalance - value;
}
}
if (to == address(0)) {
unchecked {
_totalSupply -= value;
}
} else {
unchecked {
_balances[to] += value;
}
}
emit Transfer(from, to, value);
}
function _mint(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidReceiver(address(0));
}
_update(address(0), account, value);
}
function _burn(address account, uint256 value) internal {
if (account == address(0)) {
revert ERC20InvalidSender(address(0));
}
_update(account, address(0), value);
}
function _approve(address owner, address spender, uint256 value) internal {
_approve(owner, spender, value, true);
}
function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
if (owner == address(0)) {
revert ERC20InvalidApprover(address(0));
}
if (spender == address(0)) {
revert ERC20InvalidSpender(address(0));
}
_allowances[owner][spender] = value;
if (emitEvent) {
emit Approval(owner, spender, value);
}
}
function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
if (currentAllowance < value) {
revert ERC20InsufficientAllowance(spender, currentAllowance, value);
}
unchecked {
_approve(owner, spender, currentAllowance - value, false);
}
}
}
}
文件 5 的 20:ERC20Burnable.sol
pragma solidity ^0.8.20;
import {ERC20} from "../ERC20.sol";
import {Context} from "../../../utils/Context.sol";
abstract contract ERC20Burnable is Context, ERC20 {
function burn(uint256 value) public virtual {
_burn(_msgSender(), value);
}
function burnFrom(address account, uint256 value) public virtual {
_spendAllowance(account, _msgSender(), value);
_burn(account, value);
}
}
文件 6 的 20:EnumerableSet.sol
pragma solidity ^0.8.20;
library EnumerableSet {
struct Set {
bytes32[] _values;
mapping(bytes32 value => uint256) _positions;
}
function _add(Set storage set, bytes32 value) private returns (bool) {
if (!_contains(set, value)) {
set._values.push(value);
set._positions[value] = set._values.length;
return true;
} else {
return false;
}
}
function _remove(Set storage set, bytes32 value) private returns (bool) {
uint256 position = set._positions[value];
if (position != 0) {
uint256 valueIndex = position - 1;
uint256 lastIndex = set._values.length - 1;
if (valueIndex != lastIndex) {
bytes32 lastValue = set._values[lastIndex];
set._values[valueIndex] = lastValue;
set._positions[lastValue] = position;
}
set._values.pop();
delete set._positions[value];
return true;
} else {
return false;
}
}
function _contains(Set storage set, bytes32 value) private view returns (bool) {
return set._positions[value] != 0;
}
function _length(Set storage set) private view returns (uint256) {
return set._values.length;
}
function _at(Set storage set, uint256 index) private view returns (bytes32) {
return set._values[index];
}
function _values(Set storage set) private view returns (bytes32[] memory) {
return set._values;
}
struct Bytes32Set {
Set _inner;
}
function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _add(set._inner, value);
}
function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
return _remove(set._inner, value);
}
function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
return _contains(set._inner, value);
}
function length(Bytes32Set storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
return _at(set._inner, index);
}
function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
bytes32[] memory store = _values(set._inner);
bytes32[] memory result;
assembly {
result := store
}
return result;
}
struct AddressSet {
Set _inner;
}
function add(AddressSet storage set, address value) internal returns (bool) {
return _add(set._inner, bytes32(uint256(uint160(value))));
}
function remove(AddressSet storage set, address value) internal returns (bool) {
return _remove(set._inner, bytes32(uint256(uint160(value))));
}
function contains(AddressSet storage set, address value) internal view returns (bool) {
return _contains(set._inner, bytes32(uint256(uint160(value))));
}
function length(AddressSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(AddressSet storage set, uint256 index) internal view returns (address) {
return address(uint160(uint256(_at(set._inner, index))));
}
function values(AddressSet storage set) internal view returns (address[] memory) {
bytes32[] memory store = _values(set._inner);
address[] memory result;
assembly {
result := store
}
return result;
}
struct UintSet {
Set _inner;
}
function add(UintSet storage set, uint256 value) internal returns (bool) {
return _add(set._inner, bytes32(value));
}
function remove(UintSet storage set, uint256 value) internal returns (bool) {
return _remove(set._inner, bytes32(value));
}
function contains(UintSet storage set, uint256 value) internal view returns (bool) {
return _contains(set._inner, bytes32(value));
}
function length(UintSet storage set) internal view returns (uint256) {
return _length(set._inner);
}
function at(UintSet storage set, uint256 index) internal view returns (uint256) {
return uint256(_at(set._inner, index));
}
function values(UintSet storage set) internal view returns (uint256[] memory) {
bytes32[] memory store = _values(set._inner);
uint256[] memory result;
assembly {
result := store
}
return result;
}
}
文件 7 的 20:IDividendToken.sol
pragma solidity ^0.8.24;
interface IDividendToken {
event ExcludeFromFees(address indexed account, bool isExcluded);
event SetAutomatedMarketMakerPair(address indexed pair, bool indexed value);
event SendDividends(uint256 amount);
event ProcessedDividendTracker(
uint256 iterations,
uint256 claims,
uint256 lastProcessedIndex,
bool indexed automatic,
uint256 gas,
address indexed processor
);
error InvalidFee(uint256 totalFee);
error DeactivationTooEarly();
error CannotRemoveUniswapPair(address pair);
error PairAlreadySetToValue(address pair, bool value);
error BurningAlreadyInProgress();
error BurningNotStarted();
error AlreadyDeactivated();
error NoLPTokensAvailable();
function getTokenHolders() external view returns (address[] memory);
function tokenDeactivationTime() external view returns (uint256);
function getLargestHolder() external view returns (address largestHolder, uint256 largestBalance);
function excludeFromFees(address account, bool excluded) external;
function setTeamWallet(address payable wallet) external;
function setGemStakingWallet(address payable wallet) external;
function setLargestHolderWallet(address payable wallet) external;
function setRewardsFee(uint256 value) external;
function setAuctionHouseBidFee(uint256 value) external;
function setTeamFee(uint256 value) external;
function setGemStakingFee(uint256 value) external;
function setLargestHolderFee(uint256 value) external;
function startBurning() external;
function burnNextBatch(uint256 batchSize) external;
function isBurningCompleted() external view returns (bool);
function setAutomatedMarketMakerPair(address pair, bool value) external;
function updateClaimWait(uint256 claimWait) external;
function isExcludedFromFees(address account) external view returns (bool);
function withdrawableDividendOf(address account) external view returns (uint256);
function excludeFromDividends(address account) external;
function processDividendTracker(uint256 gas) external;
function claim() external;
}
文件 8 的 20:IDividendTracker.sol
pragma solidity ^0.8.24;
interface IDividendTracker {
event ExcludeFromDividends(address indexed account);
event ClaimWaitUpdated(uint256 indexed newValue, uint256 indexed oldValue);
event Claim(address indexed account, uint256 amount, bool indexed automatic);
event DividendsDistributed(address indexed from, uint256 weiAmount);
event DividendWithdrawn(address indexed to, uint256 weiAmount);
error InvalidClaimWait(uint256 provided, uint256 min, uint256 max);
error ClaimWaitAlreadySet(uint256 provided);
error NoTotalSupply();
function excludeFromDividends(address account) external;
function updateClaimWait(uint256 newClaimWait) external;
function getNumberOfTokenHolders() external view returns (uint256);
function getTokenHolderBalance(address account) external view returns (uint256);
function getAccount(
address _account
)
external
view
returns (
address account,
int256 index,
int256 iterationsUntilProcessed,
uint256 withdrawableDividends,
uint256 totalDividends,
uint256 lastClaimTime,
uint256 nextClaimTime,
uint256 secondsUntilAutoClaimAvailable
);
function getAccountAtIndex(
uint256 index
) external view returns (address, int256, int256, uint256, uint256, uint256, uint256, uint256);
function process(uint256 gas) external returns (uint256, uint256, uint256);
function processAccount(address payable account, bool automatic) external returns (bool);
function distributeDividends(uint256 amount) external;
function withdrawDividend() external;
function withdrawableDividendOf(address _owner) external view returns (uint256);
function withdrawnDividendOf(address _owner) external view returns (uint256);
function accumulativeDividendOf(address _owner) external view returns (uint256);
function getLargestHolder() external view returns (address largestHolder, uint256 largestBalance);
function setBalance(address payable account, uint256 newBalance) external;
}
文件 9 的 20:IERC20.sol
pragma solidity ^0.8.20;
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 value) external returns (bool);
function allowance(address owner, address spender) external view returns (uint256);
function approve(address spender, uint256 value) external returns (bool);
function transferFrom(address from, address to, uint256 value) external returns (bool);
}
文件 10 的 20:IERC20Metadata.sol
pragma solidity ^0.8.20;
import {IERC20} from "../IERC20.sol";
interface IERC20Metadata is IERC20 {
function name() external view returns (string memory);
function symbol() external view returns (string memory);
function decimals() external view returns (uint8);
}
文件 11 的 20:IRestrictedWithdrawal.sol
pragma solidity ^0.8.24;
interface IRestrictedWithdrawal {
error InvalidDividendTrackerAddress();
error InvalidDividendTokenAddress();
error TokenStillActive();
error NoFundsToWithdraw();
function withdraw() external;
}
文件 12 的 20: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 的 20: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 的 20: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 的 20: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 的 20:IterableMapping.sol
pragma solidity ^0.8.24;
library IterableMapping {
struct Map {
address[] keys;
mapping(address => uint) values;
mapping(address => uint) indexOf;
mapping(address => bool) inserted;
}
function get(Map storage map, address key) internal view returns (uint) {
return map.values[key];
}
function getIndexOfKey(Map storage map, address key) internal view returns (int) {
if (!map.inserted[key]) {
return -1;
}
return int(map.indexOf[key]);
}
function getKeyAtIndex(Map storage map, uint index) internal view returns (address) {
return map.keys[index];
}
function size(Map storage map) internal view returns (uint) {
return map.keys.length;
}
function set(Map storage map, address key, uint val) internal {
if (map.inserted[key]) {
map.values[key] = val;
} else {
map.inserted[key] = true;
map.values[key] = val;
map.indexOf[key] = map.keys.length;
map.keys.push(key);
}
}
function remove(Map storage map, address key) internal {
if (!map.inserted[key]) {
return;
}
delete map.inserted[key];
delete map.values[key];
uint index = map.indexOf[key];
uint lastIndex = map.keys.length - 1;
address lastKey = map.keys[lastIndex];
map.indexOf[lastKey] = index;
delete map.indexOf[key];
map.keys[index] = lastKey;
map.keys.pop();
}
}
文件 17 的 20:Ownable.sol
pragma solidity ^0.8.20;
import {Context} from "../utils/Context.sol";
abstract contract Ownable is Context {
address private _owner;
error OwnableUnauthorizedAccount(address account);
error OwnableInvalidOwner(address owner);
event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);
constructor(address initialOwner) {
if (initialOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(initialOwner);
}
modifier onlyOwner() {
_checkOwner();
_;
}
function owner() public view virtual returns (address) {
return _owner;
}
function _checkOwner() internal view virtual {
if (owner() != _msgSender()) {
revert OwnableUnauthorizedAccount(_msgSender());
}
}
function renounceOwnership() public virtual onlyOwner {
_transferOwnership(address(0));
}
function transferOwnership(address newOwner) public virtual onlyOwner {
if (newOwner == address(0)) {
revert OwnableInvalidOwner(address(0));
}
_transferOwnership(newOwner);
}
function _transferOwnership(address newOwner) internal virtual {
address oldOwner = _owner;
_owner = newOwner;
emit OwnershipTransferred(oldOwner, newOwner);
}
}
文件 18 的 20:ReentrancyGuard.sol
pragma solidity ^0.8.20;
abstract contract ReentrancyGuard {
uint256 private constant NOT_ENTERED = 1;
uint256 private constant ENTERED = 2;
uint256 private _status;
error ReentrancyGuardReentrantCall();
constructor() {
_status = NOT_ENTERED;
}
modifier nonReentrant() {
_nonReentrantBefore();
_;
_nonReentrantAfter();
}
function _nonReentrantBefore() private {
if (_status == ENTERED) {
revert ReentrancyGuardReentrantCall();
}
_status = ENTERED;
}
function _nonReentrantAfter() private {
_status = NOT_ENTERED;
}
function _reentrancyGuardEntered() internal view returns (bool) {
return _status == ENTERED;
}
}
文件 19 的 20:RestrictedWithdrawal.sol
pragma solidity ^0.8.24;
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";
import {DividendTracker} from "./DividendTracker.sol";
import {DividendToken} from "./DividendToken.sol";
import {IRestrictedWithdrawal} from "./IRestrictedWithdrawal.sol";
contract RestrictedWithdrawal is IRestrictedWithdrawal, ReentrancyGuard {
DividendTracker public dividendTracker;
DividendToken public dividendToken;
constructor(address _dividendTracker, address _dividendToken) {
if (_dividendTracker == address(0)) {
revert InvalidDividendTrackerAddress();
}
if (_dividendToken == address(0)) {
revert InvalidDividendTokenAddress();
}
dividendToken = DividendToken(payable(_dividendToken));
dividendTracker = DividendTracker(payable(_dividendTracker));
}
function withdraw() external nonReentrant {
if (dividendToken.isActive()) {
revert TokenStillActive();
}
(address largestHolder, ) = dividendTracker.getLargestHolder();
uint256 balance = address(this).balance;
if (balance == 0) {
revert NoFundsToWithdraw();
}
_safeTransferETH(largestHolder, balance);
}
function _safeTransferETH(address to, uint256 value) private returns (bool) {
(bool success, ) = to.call{value: value, gas: 30_000}(new bytes(0));
return success;
}
receive() external payable {}
fallback() external payable {}
}
文件 20 的 20:draft-IERC6093.sol
pragma solidity ^0.8.20;
interface IERC20Errors {
error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);
error ERC20InvalidSender(address sender);
error ERC20InvalidReceiver(address receiver);
error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);
error ERC20InvalidApprover(address approver);
error ERC20InvalidSpender(address spender);
}
interface IERC721Errors {
error ERC721InvalidOwner(address owner);
error ERC721NonexistentToken(uint256 tokenId);
error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);
error ERC721InvalidSender(address sender);
error ERC721InvalidReceiver(address receiver);
error ERC721InsufficientApproval(address operator, uint256 tokenId);
error ERC721InvalidApprover(address approver);
error ERC721InvalidOperator(address operator);
}
interface IERC1155Errors {
error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);
error ERC1155InvalidSender(address sender);
error ERC1155InvalidReceiver(address receiver);
error ERC1155MissingApprovalForAll(address operator, address owner);
error ERC1155InvalidApprover(address approver);
error ERC1155InvalidOperator(address operator);
error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}
{
"compilationTarget": {
"contracts/dividend/DividendToken.sol": "DividendToken"
},
"evmVersion": "paris",
"libraries": {},
"metadata": {
"bytecodeHash": "ipfs"
},
"optimizer": {
"enabled": true,
"runs": 200
},
"remappings": [],
"viaIR": true
}
[{"inputs":[{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"uint256","name":"_initialSupply","type":"uint256"},{"internalType":"address","name":"_router","type":"address"},{"internalType":"uint256","name":"_minimumTokenBalanceForDividendsPct","type":"uint256"},{"internalType":"address","name":"_gem","type":"address"},{"internalType":"uint256","name":"_deactivationPeriodInSeconds","type":"uint256"},{"internalType":"uint256","name":"_dividendsFee","type":"uint256"},{"internalType":"uint256","name":"_largestHolderFee","type":"uint256"},{"internalType":"address","name":"_auctionHouseBidWallet","type":"address"},{"internalType":"uint256","name":"_auctionHouseBidFee","type":"uint256"},{"internalType":"address","name":"_teamWallet","type":"address"},{"internalType":"uint256","name":"_teamFee","type":"uint256"},{"internalType":"address","name":"_gemStakingWallet","type":"address"},{"internalType":"uint256","name":"_gemStakingFee","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AlreadyDeactivated","type":"error"},{"inputs":[],"name":"BurningAlreadyInProgress","type":"error"},{"inputs":[],"name":"BurningNotStarted","type":"error"},{"inputs":[{"internalType":"address","name":"pair","type":"address"}],"name":"CannotRemoveUniswapPair","type":"error"},{"inputs":[],"name":"DeactivationTooEarly","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"uint256","name":"totalFee","type":"uint256"}],"name":"InvalidFee","type":"error"},{"inputs":[],"name":"NoLPTokensAvailable","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"PairAlreadySetToValue","type":"error"},{"inputs":[],"name":"ReentrancyGuardReentrantCall","type":"error"},{"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":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"bool","name":"isExcluded","type":"bool"}],"name":"ExcludeFromFees","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":false,"internalType":"uint256","name":"iterations","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"claims","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lastProcessedIndex","type":"uint256"},{"indexed":true,"internalType":"bool","name":"automatic","type":"bool"},{"indexed":false,"internalType":"uint256","name":"gas","type":"uint256"},{"indexed":true,"internalType":"address","name":"processor","type":"address"}],"name":"ProcessedDividendTracker","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"SendDividends","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"pair","type":"address"},{"indexed":true,"internalType":"bool","name":"value","type":"bool"}],"name":"SetAutomatedMarketMakerPair","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":"PINK_LOCK_CONTRACT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"_isExcludedFromFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"auctionHouseBidFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"auctionHouseBidWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"automatedMarketMakerPairs","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"batchSize","type":"uint256"}],"name":"burnNextBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"currentBatchIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deactivationPeriodInSeconds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deployerWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deploymentTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dividendTracker","outputs":[{"internalType":"contract DividendTracker","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"dividendsFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"excludeFromDividends","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bool","name":"excluded","type":"bool"}],"name":"excludeFromFees","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"gem","outputs":[{"internalType":"contract IERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gemStakingFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gemStakingWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getLargestHolder","outputs":[{"internalType":"address","name":"largestHolder","type":"address"},{"internalType":"uint256","name":"largestBalance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTokenHolders","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isBurning","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isBurningCompleted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"isExcludedFromFees","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isRemoveLiquidity","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"largestHolderFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"largestHolderWallet","outputs":[{"internalType":"contract RestrictedWithdrawal","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":"uint256","name":"value","type":"uint256"}],"name":"setAuctionHouseBidFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"pair","type":"address"},{"internalType":"bool","name":"value","type":"bool"}],"name":"setAutomatedMarketMakerPair","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"setGemStakingFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"wallet","type":"address"}],"name":"setGemStakingWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"setLargestHolderFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"wallet","type":"address"}],"name":"setLargestHolderWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"setRewardsFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"value","type":"uint256"}],"name":"setTeamFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"wallet","type":"address"}],"name":"setTeamWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"startBurning","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"swapTokensAtAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"teamWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tokenDeactivationTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","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":[],"name":"uniswapV2Pair","outputs":[{"internalType":"contract IUniswapV2Pair","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"uniswapV2Router","outputs":[{"internalType":"contract IUniswapV2Router02","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"claimWait","type":"uint256"}],"name":"updateClaimWait","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"withdrawableDividendOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]