Contract Address Details

//SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/utils/ReentrancyGuard.sol


// OpenZeppelin Contracts (last updated v5.1.0) (utils/ReentrancyGuard.sol)

pragma solidity ^0.8.20;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If EIP-1153 (transient storage) is available on the chain you're deploying at,
 * consider using {ReentrancyGuardTransient} instead.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant NOT_ENTERED = 1;
    uint256 private constant ENTERED = 2;

    uint256 private _status;

    /**
     * @dev Unauthorized reentrant call.
     */
    error ReentrancyGuardReentrantCall();

    constructor() {
        _status = NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        _nonReentrantBefore();
        _;
        _nonReentrantAfter();
    }

    function _nonReentrantBefore() private {
        // On the first call to nonReentrant, _status will be NOT_ENTERED
        if (_status == ENTERED) {
            revert ReentrancyGuardReentrantCall();
        }

        // Any calls to nonReentrant after this point will fail
        _status = ENTERED;
    }

    function _nonReentrantAfter() private {
        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = NOT_ENTERED;
    }

    /**
     * @dev Returns true if the reentrancy guard is currently set to "entered", which indicates there is a
     * `nonReentrant` function in the call stack.
     */
    function _reentrancyGuardEntered() internal view returns (bool) {
        return _status == ENTERED;
    }
}

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

pragma solidity ^0.8.20;


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

// File: contracts/Gelato.sol

pragma solidity 0.8.20;



/**
 * Standard SafeMath, stripped down to just add/sub/mul/div
 */
library SafeMath {
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return sub(a, b, "SafeMath: subtraction overflow");
    }

    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        uint256 c = a - b;

        return c;
    }

    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return div(a, b, "SafeMath: division by zero");
    }

    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        // Solidity only automatically asserts when dividing by 0
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }
}

/**
 * ERC20 standard interface.
 */
interface IERC20 {
    function totalSupply() external view returns (uint256);

    function decimals() external view returns (uint8);

    function symbol() external view returns (string memory);

    function name() external view returns (string memory);

    function balanceOf(address account) external view returns (uint256);

    function transfer(
        address recipient,
        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 sender,
        address recipient,
        uint256 amount
    ) external returns (bool);

    event Transfer(address indexed from, address indexed to, uint256 value);
    event Approval(
        address indexed owner,
        address indexed spender,
        uint256 value
    );
}

interface ISOLIDX {
    function burn(uint256 amount) external;
}

interface ISTACKED {
    function burn(uint256 amount) external;
}

interface IDEXFactory {
    function createPair(
        address tokenA,
        address tokenB
    ) external returns (address pair);
}

interface IDEXRouter {
    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 swapExactTokensForTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;

    function swapExactETHForTokens(
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external payable;

    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 IDividendDistributor {
    function setDistributionCriteria(
        uint256 _minSolidXPeriod,
        uint256 _minSolidXDistribution,
        uint256 _minHexPeriod,
        uint256 _minHexDistribution
    ) external;

    function setShare(address shareholder, uint256 amount) external;

    function depositForSolidXBurn() external payable;

    function depositForStackedBurn() external payable;

    function depositForSolidXReflection() external payable;

    function depositForHexReflection() external payable;

    function processSolidX(uint256 gas) external;

    function processHex(uint256 gas) external;

    function claimDividend() external;
}

contract DividendDistributor is IDividendDistributor {
    using SafeMath for uint256;

    address _token;

    struct Share {
        uint256 amount;
        uint256 solidXTotalExcluded;
        uint256 solidXTotalRealised;
        uint256 hexTotalExcluded;
        uint256 hexTotalRealised;
    }

    IERC20 SOLIDX = IERC20(0x8Da17Db850315A34532108f0f5458fc0401525f6);
    IERC20 HEX = IERC20(0x2b591e99afE9f32eAA6214f7B7629768c40Eeb39);
    IERC20 STACKED = IERC20(0x67d8954C2B7386c8Dbf6936Cc2355bA2227F0a8f);
    IERC20 WPLS = IERC20(0xA1077a294dDE1B09bB078844df40758a5D0f9a27);
    address ZERO = 0x0000000000000000000000000000000000000000;
    IDEXRouter public pulseRouterV1;
    IDEXRouter public pulseRouterV2;
    IDEXRouter public nineinchRouter;

    address[] shareholders;
    mapping(address => uint256) shareholderSolidXIndexes;
    mapping(address => uint256) shareholderSolidXClaims;
    mapping(address => uint256) shareholderHexIndexes;
    mapping(address => uint256) shareholderHexClaims;

    mapping(address => Share) public shares;
    uint256 public totalShares;

    // SolidX Trackers
    uint256 currentSolidXIndex;
    uint256 public totalSolidXDividends;
    uint256 public totalSolidXDistributed;
    uint256 public solidXDividendsPerShare;
    uint256 public solidXDividendsPerShareAccuracyFactor = 10 ** 36;
    uint256 public minSolidXPeriod = 1 hours; // min 1 hour delay
    uint256 public minSolidXDistribution = (1 * (10 ** 18)) / 10; // 0.1 SOLIDX minimum auto send
    uint256 public totalSolidXBurned;

    // HEX Dividend Trackers
    uint256 currentHexIndex;
    uint256 public totalHexDividends;
    uint256 public totalHexDistributed;
    uint256 public hexDividendsPerShare;
    uint256 public hexDividendsPerShareAccuracyFactor = 10 ** 36;
    uint256 public minHexPeriod = 1 hours; // min 1 hour delay
    uint256 public minHexDistribution = 100 * (10 ** 8); // 100 HEX minimum auto send

    // Stacked Italian Trackers
    uint256 public totalStackedBurned;

    bool initialized;

    modifier initialization() {
        require(!initialized);
        _;
        initialized = true;
    }

    modifier onlyToken() {
        require(msg.sender == _token);
        _;
    }

    constructor(address _pulseRouterV1, address _pulseRouterV2, address _nineinchRouter) {
        pulseRouterV1 = _pulseRouterV1 != address(0)
            ? IDEXRouter(_pulseRouterV1)
            : IDEXRouter(0x98bf93ebf5c380C0e6Ae8e192A7e2AE08edAcc02);
        pulseRouterV2 = _pulseRouterV2 != address(0)
            ? IDEXRouter(_pulseRouterV2)
            : IDEXRouter(0x165C3410fC91EF562C50559f7d2289fEbed552d9);
        nineinchRouter = _nineinchRouter != address(0)
            ? IDEXRouter(_nineinchRouter)
            : IDEXRouter(0xeB45a3c4aedd0F47F345fB4c8A1802BB5740d725);
        _token = msg.sender;

        STACKED.approve(address(STACKED), type(uint256).max);
    }

    function setDistributionCriteria(
        uint256 _minSolidXPeriod,
        uint256 _minSolidXDistribution,
        uint256 _minHexPeriod,
        uint256 _minHexDistribution
    ) external override onlyToken {
        minSolidXPeriod = _minSolidXPeriod;
        minSolidXDistribution = _minSolidXDistribution;
        minHexPeriod = _minHexPeriod;
        minHexDistribution = _minHexDistribution;
    }

    function setShare(
        address shareholder,
        uint256 amount
    ) external override onlyToken {
        if (shares[shareholder].amount > 0) {
            distributeSolidXDividend(shareholder);
            distributeHexDividend(shareholder);
        }

        if (amount > 0 && shares[shareholder].amount == 0) {
            addShareholder(shareholder);
        } else if (amount == 0 && shares[shareholder].amount > 0) {
            removeShareholder(shareholder);
        }

        totalShares = totalShares.sub(shares[shareholder].amount).add(amount);
        shares[shareholder].amount = amount;

        shares[shareholder].solidXTotalExcluded = getCumulativeSolidXDividends(
            shares[shareholder].amount
        );

        shares[shareholder].hexTotalExcluded = getCumulativeHexDividends(
            shares[shareholder].amount
        );
    }

    function depositForSolidXBurn() external payable override onlyToken {
        uint256 solidXBefore = SOLIDX.balanceOf(address(this));

        address[] memory path = new address[](2);
        path[0] = address(WPLS);
        path[1] = address(SOLIDX);

        nineinchRouter.swapExactETHForTokens{value: msg.value}(
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 solidXGained = SOLIDX.balanceOf(address(this)).sub(
            solidXBefore
        );

        ISOLIDX(address(SOLIDX)).burn(solidXGained);
        totalSolidXBurned = totalSolidXBurned.add(solidXGained);
    }

    function depositForStackedBurn() external payable override onlyToken {
        uint256 stackedBalanceBefore = STACKED.balanceOf(address(this));

        address[] memory path = new address[](2);
        path[0] = address(WPLS);
        path[1] = address(STACKED);

        nineinchRouter.swapExactETHForTokens{value: msg.value}(
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 stackedGained = STACKED.balanceOf(address(this)).sub(
            stackedBalanceBefore
        );

        ISTACKED(address(STACKED)).burn(stackedGained);
        totalStackedBurned = totalStackedBurned.add(stackedGained);
    }

    function depositForSolidXReflection() external payable override onlyToken {
        uint256 solidXBalanceBefore = SOLIDX.balanceOf(address(this));

        address[] memory path = new address[](2);
        path[0] = address(WPLS);
        path[1] = address(SOLIDX);

        nineinchRouter.swapExactETHForTokens{value: msg.value}(
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 solidXGained = SOLIDX.balanceOf(address(this)).sub(
            solidXBalanceBefore
        );

        totalSolidXDividends = totalSolidXDividends.add(solidXGained);
        solidXDividendsPerShare = solidXDividendsPerShare.add(
            solidXDividendsPerShareAccuracyFactor.mul(solidXGained).div(
                totalShares
            )
        );
    }

    function depositForHexReflection() external payable override onlyToken {
        uint256 hexBalanceBefore = HEX.balanceOf(address(this));

        address[] memory path = new address[](2);
        path[0] = address(WPLS);
        path[1] = address(HEX);

        pulseRouterV1.swapExactETHForTokens{value: msg.value}(
            0,
            path,
            address(this),
            block.timestamp
        );

        uint256 hexGained = HEX.balanceOf(address(this)).sub(hexBalanceBefore);

        totalHexDividends = totalHexDividends.add(hexGained);
        hexDividendsPerShare = hexDividendsPerShare.add(
            hexDividendsPerShareAccuracyFactor.mul(hexGained).div(totalShares)
        );
    }

    function distributeSolidXDividend(address shareholder) internal {
        if (shares[shareholder].amount == 0) {
            return;
        }

        uint256 amount = getUnpaidSolidXEarnings(shareholder);
        if (amount > 0) {
            totalSolidXDistributed = totalSolidXDistributed.add(amount);
            SOLIDX.transfer(shareholder, amount);
            shareholderSolidXClaims[shareholder] = block.timestamp;
            shares[shareholder].solidXTotalRealised = shares[shareholder]
                .solidXTotalRealised
                .add(amount);
            shares[shareholder]
                .solidXTotalExcluded = getCumulativeSolidXDividends(
                shares[shareholder].amount
            );
        }
    }

    function distributeHexDividend(address shareholder) internal {
        if (shares[shareholder].amount == 0) {
            return;
        }

        uint256 amount = getUnpaidHexEarnings(shareholder);
        if (amount > 0) {
            totalHexDistributed = totalHexDistributed.add(amount);
            HEX.transfer(shareholder, amount);
            shareholderHexClaims[shareholder] = block.timestamp;
            shares[shareholder].hexTotalRealised = shares[shareholder]
                .hexTotalRealised
                .add(amount);
            shares[shareholder].hexTotalExcluded = getCumulativeHexDividends(
                shares[shareholder].amount
            );
        }
    }

    function processSolidX(uint256 gas) external override onlyToken {
        uint256 shareholderCount = shareholders.length;

        if (shareholderCount == 0) {
            return;
        }

        uint256 gasUsed = 0;
        uint256 gasLeft = gasleft();

        uint256 iterations = 0;

        while (gasUsed < gas && iterations < shareholderCount) {
            if (currentSolidXIndex >= shareholderCount) {
                currentSolidXIndex = 0;
            }

            if (shouldSolidXDistribute(shareholders[currentSolidXIndex])) {
                distributeSolidXDividend(shareholders[currentSolidXIndex]);
            }

            gasUsed = gasUsed.add(gasLeft.sub(gasleft()));
            gasLeft = gasleft();
            currentSolidXIndex++;
            iterations++;
        }
    }

    function processHex(uint256 gas) external override onlyToken {
        uint256 shareholderCount = shareholders.length;

        if (shareholderCount == 0) {
            return;
        }

        uint256 gasUsed = 0;
        uint256 gasLeft = gasleft();

        uint256 iterations = 0;

        while (gasUsed < gas && iterations < shareholderCount) {
            if (currentHexIndex >= shareholderCount) {
                currentHexIndex = 0;
            }

            if (shouldHexDistribute(shareholders[currentHexIndex])) {
                distributeHexDividend(shareholders[currentHexIndex]);
            }

            gasUsed = gasUsed.add(gasLeft.sub(gasleft()));
            gasLeft = gasleft();
            currentHexIndex++;
            iterations++;
        }
    }

    function shouldSolidXDistribute(
        address shareholder
    ) internal view returns (bool) {
        return
            shareholderSolidXClaims[shareholder] + minSolidXPeriod <
            block.timestamp &&
            getUnpaidSolidXEarnings(shareholder) > minSolidXDistribution;
    }

    function shouldHexDistribute(
        address shareholder
    ) internal view returns (bool) {
        return
            shareholderHexClaims[shareholder] + minHexPeriod <
            block.timestamp &&
            getUnpaidHexEarnings(shareholder) > minHexDistribution;
    }

    function claimDividend() external override {
        distributeSolidXDividend(msg.sender);
        distributeHexDividend(msg.sender);
    }

    function getUnpaidSolidXEarnings(
        address shareholder
    ) public view returns (uint256) {
        if (shares[shareholder].amount == 0) {
            return 0;
        }

        uint256 shareholderTotalDividends = getCumulativeSolidXDividends(
            shares[shareholder].amount
        );
        uint256 shareholderTotalExcluded = shares[shareholder]
            .solidXTotalExcluded;

        if (shareholderTotalDividends <= shareholderTotalExcluded) {
            return 0;
        }

        return shareholderTotalDividends.sub(shareholderTotalExcluded);
    }

    function getUnpaidHexEarnings(
        address shareholder
    ) public view returns (uint256) {
        if (shares[shareholder].amount == 0) {
            return 0;
        }

        uint256 shareholderTotalDividends = getCumulativeHexDividends(
            shares[shareholder].amount
        );
        uint256 shareholderTotalExcluded = shares[shareholder].hexTotalExcluded;

        if (shareholderTotalDividends <= shareholderTotalExcluded) {
            return 0;
        }

        return shareholderTotalDividends.sub(shareholderTotalExcluded);
    }

    function getCumulativeSolidXDividends(
        uint256 share
    ) internal view returns (uint256) {
        return
            share.mul(solidXDividendsPerShare).div(
                solidXDividendsPerShareAccuracyFactor
            );
    }

    function getCumulativeHexDividends(
        uint256 share
    ) internal view returns (uint256) {
        return
            share.mul(hexDividendsPerShare).div(
                hexDividendsPerShareAccuracyFactor
            );
    }

    function addShareholder(address shareholder) internal {
        shareholderSolidXIndexes[shareholder] = shareholders.length;
        shareholderHexIndexes[shareholder] = shareholders.length;

        shareholders.push(shareholder);
    }

    function removeShareholder(address shareholder) internal {
        shareholders[shareholderSolidXIndexes[shareholder]] = shareholders[
            shareholders.length - 1
        ];
        shareholderSolidXIndexes[
            shareholders[shareholders.length - 1]
        ] = shareholderSolidXIndexes[shareholder];

        shareholders[shareholderHexIndexes[shareholder]] = shareholders[
            shareholders.length - 1
        ];
        shareholderHexIndexes[
            shareholders[shareholders.length - 1]
        ] = shareholderHexIndexes[shareholder];

        shareholders.pop();
    }

    receive() external payable {}
}