PulseChain Explorer - BlockScout

Contract Address

Is Yul contract

No

Yes

Contract Name

Include nightly builds

No

Yes

Compiler

EVM Version

Optimization

No

Yes

Optimization runs

Enter the Solidity Contract Code

/*
 * @title REFLUX - Earn reflections in native token
 * @author Ra Murd <pulselorian@gmail.com>
 * @notice https://pulselorian.com/
 * @notice https://t.me/ThePulselorian
 * @notice https://twitter.com/ThePulseLorian
 *
 * It's deflationary, burns portion of the fees, reflects rest of the fees in native tokens
 *
 *    (   (  (  (     (   (( (   .  (   (    (( (   ((
 *    )\  )\ )\ )\    )\ (\())\   . )\  )\   ))\)\  ))\
 *   ((_)((_)(_)(_)  ((_))(_)(_)   ((_)((_)(((_)_()((_)))
 *   | _ \ | | | |  / __| __| |   / _ \| _ \_ _|   \ \| |
 *   |  _/ |_| | |__\__ \ _|| |__| (_) |   /| || - | .  |
 *   |_|  \___/|____|___/___|____|\___/|_|_\___|_|_|_|\_|
 *
 * Tokenomics (initial fees):
 *          Buy      Sell     Transfer
 * Rfi      1.75%    1.75%    0.0%
 * Burn     0.25%    0.25%    0.0%
 *
 * SPDX-License-Identifier: MIT
 */

pragma solidity 0.8.21;

import "./@openzeppelin/access/AccessControl.sol";
import "./@openzeppelin/access/Ownable.sol";
import "./@openzeppelin/token/ERC20/ERC20.sol";
import "./@uniswap/v2-core/interfaces/IUniswapV2Factory.sol";
import "./@uniswap/v2-core/interfaces/IUniswapV2Pair.sol";
import "./@uniswap/v2-periphery/interfaces/IUniswapV2Router02.sol";
import "./lib/RfiHelper.sol";
import "./lib/Utils.sol";

contract Reflux is ERC20, Ownable, Utils, AccessControl {
    enum Fees {
        BuyRfiFee,
        BuyBurnFee,
        SellRfiFee,
        SellBurnFee
    }

IUniswapV2Pair public plsV2LP;
    IUniswapV2Router02 public plsxV2Router;
    RfiHelper public rfiHelper;

address private _prevFrom;
    address private _prevTo;
    address public burnAddr;
    address public rfiHelperAddr;

bool private _swapping;
    bool public payoutEnabled = true;

bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");

mapping(address => bool) public isAMMPair;
    mapping(address => bool) public noFee;
    mapping(address => bool) public noRfi;

uint256 private constant _BIPS = 10000;
    uint256 private constant _MAX_FEE = 500;

uint256 public lpRewardBips = 20000;
    uint256 public maxGas = 200000;
    uint256 public swapFactor = 1e5;

uint256[] public fees = new uint256[](uint256(type(Fees).max) + 1);

event UpdatedNoFeeWallet(address wallet, bool status);
    event SwapFactorUpdated(uint256 newFactor);
    event FeesUpdated(
        uint256 buyRfiFee,
        uint256 buyBurnFee,
        uint256 sellRfiFee,
        uint256 sellBurnFee
    );

constructor(address plsxV2Router_) ERC20("REFLUX | Interest", "RFX") {
        burnAddr = address(0x369);
        plsxV2Router = IUniswapV2Router02(plsxV2Router_);
        address plsLPAddr = IUniswapV2Factory(plsxV2Router.factory())
            .createPair(address(this), plsxV2Router.WPLS());
        plsV2LP = IUniswapV2Pair(plsLPAddr);

rfiHelper = new RfiHelper();
        rfiHelperAddr = address(rfiHelper);

fees[uint256(Fees.BuyRfiFee)] = 175;
        fees[uint256(Fees.BuyBurnFee)] = 25;
        fees[uint256(Fees.SellRfiFee)] = 175;
        fees[uint256(Fees.SellBurnFee)] = 25;

noFee[address(this)] = true;
        noFee[msg.sender] = true;

noRfi[address(this)] = true;
        noRfi[burnAddr] = true;
        noRfi[plsLPAddr] = true;
        noRfi[address(0)] = true;

isAMMPair[plsLPAddr] = true;

_mint(msg.sender, 1e27); // 1 billion

_grantRole(MANAGER_ROLE, msg.sender);
    }

receive() external payable {}

function _calcShares(
        address target_
    ) private view returns (uint256 shares) {
        return
            balanceOf(target_) +
            (lpRewardBips * plsV2LP.balanceOf(target_)) /
            _BIPS;
    }

function _swapTokensForPLS(
        uint256 tknAmt_
    ) private returns (uint256 plsFromSwap) {
        address[] memory path = new address[](2);
        path[0] = address(this);
        path[1] = plsxV2Router.WPLS();

uint256 plsBalBefore = address(rfiHelperAddr).balance;
        _approve(address(this), address(plsxV2Router), tknAmt_);
        plsxV2Router.swapExactTokensForETHSupportingFeeOnTransferTokens(
            tknAmt_,
            0,
            path,
            rfiHelperAddr,
            block.timestamp
        );
        plsFromSwap = address(rfiHelperAddr).balance - plsBalBefore;
    }

function _transfer(
        address from_,
        address to_,
        uint256 amt_
    ) internal override(ERC20) {
        _checkIfAMMPair(from_);
        _checkIfAMMPair(to_);

uint256 rfiTknBal = balanceOf(address(this));
        bool swapReady = rfiTknBal >= (totalSupply() / swapFactor);

// Sell transaction when _swapping is enabled and _swapping is not in progress
        if (swapReady && !_swapping && isAMMPair[to_]) {
            _swapping = true;
            uint256 plsFromSwap = _swapTokensForPLS(totalSupply() / swapFactor);
            rfiHelper.deposit(plsFromSwap);
            _swapping = false;
        }

if (noFee[from_] || noFee[to_]) {
            super._transfer(from_, to_, amt_);
        } else {
            (uint256 burnFee, uint256 rfiFee) = calcFees(
                amt_,
                isAMMPair[from_],
                isAMMPair[to_]
            );
            if (burnFee > 0) {
                super._transfer(from_, address(burnAddr), burnFee);
            }
            if (rfiFee > 0) {
                super._transfer(from_, address(this), rfiFee);
            }
            super._transfer(from_, to_, amt_ - burnFee - rfiFee);
        }

_transferPost(from_, to_);
    }

function _transferPost(address from_, address to_) private {
        if (!noRfi[_prevFrom]) {
            try
                rfiHelper.setShare(_prevFrom, _calcShares(_prevFrom))
            {} catch {}
        }

if (!noRfi[_prevTo]) {
            try rfiHelper.setShare(_prevTo, _calcShares(_prevTo)) {} catch {}
        }

if (!noRfi[from_]) {
            _prevFrom = from_;
            try rfiHelper.setShare(from_, _calcShares(from_)) {} catch {}
        }
        if (!noRfi[to_]) {
            _prevTo = to_;
            try rfiHelper.setShare(to_, _calcShares(to_)) {} catch {}
        }

if (payoutEnabled) {
            try rfiHelper.process(maxGas) {} catch {}
        }
    }

function setFees(
        uint256 buyRfiFee_,
        uint256 buyBurnFee_,
        uint256 sellRfiFee_,
        uint256 sellBurnFee_
    ) external onlyRole(MANAGER_ROLE) {
        require(
            buyRfiFee_ <= _MAX_FEE &&
                buyBurnFee_ <= _MAX_FEE &&
                sellRfiFee_ <= _MAX_FEE &&
                sellBurnFee_ <= _MAX_FEE,
            "Fee must be <= MAX_FEE"
        );

fees[uint256(Fees.BuyRfiFee)] = buyRfiFee_;
        fees[uint256(Fees.BuyBurnFee)] = buyBurnFee_;
        fees[uint256(Fees.SellRfiFee)] = sellRfiFee_;
        fees[uint256(Fees.SellBurnFee)] = sellBurnFee_;

emit FeesUpdated(buyRfiFee_, buyBurnFee_, sellRfiFee_, sellBurnFee_);
    }

function setLPRewardBips(
        uint256 newLPRewardBips_
    ) external onlyRole(MANAGER_ROLE) {
        lpRewardBips = newLPRewardBips_;
    }

function setMaxGas(uint256 gas_) external onlyRole(MANAGER_ROLE) {
        maxGas = gas_;
    }

function setNoFee(
        address wallet_,
        bool flag_
    ) external onlyRole(MANAGER_ROLE) {
        require(noFee[wallet_] != flag_, "Wallet already set");

noFee[wallet_] = flag_;
        emit UpdatedNoFeeWallet(wallet_, flag_);
    }

function setPayoutEnabled(bool enabled_) external onlyRole(MANAGER_ROLE) {
        payoutEnabled = enabled_;
    }

function setPayoutPolicy(
        uint256 minDurSec_,
        uint256 minReward_
    ) external onlyRole(MANAGER_ROLE) {
        rfiHelper.setPayoutPolicy(minDurSec_, minReward_);
    }

function setSwapFactor(uint256 newFac_) external onlyRole(MANAGER_ROLE) {
        require(newFac_ <= 1e12, "Too big factor");
        require(newFac_ >= 1e3, "Too small factor");

swapFactor = newFac_;
        emit SwapFactorUpdated(newFac_);
    }
}

Try to fetch constructor arguments automatically

No

Yes

ABI-encoded Constructor Arguments (if required by the contract)

New Solidity Smart Contract Verification

Contract Libraries