Contract

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "./AdderallTokenTest.sol";

contract AdderallStaking {
    AdderallToken public adderallToken;

    address public owner;
    uint256 public k = 1000; // represents 1/10th or 10%
    uint256 constant DAY_IN_SECONDS = 86400; // 24 hours * 60 minutes * 60 seconds
    uint256 public totalStaked;
    uint256 public lockupPeriod = 0 seconds;
    uint256 public rewardPerTokenStored = 0; 
    uint256 public lastUpdateTime;


    struct StakerInfo {
        uint256 stakedAmount;
        uint256 lastUpdated;
        uint256 reward;
        uint256 lastTotalRewardsPoolAtUpdate;
        uint256 lockupEndTime;
    }

    mapping(address => StakerInfo) public stakers;

    event Staked(address indexed user, uint256 amount);
    event Unstaked(address indexed user, uint256 amount);
    event RewardClaimed(address indexed user, uint256 reward);
    event DecayFactorUpdated(uint256 newK);
    event LockupPeriodUpdated(uint256 newLockupPeriod);

    modifier onlyOwner() {
        require(msg.sender == owner, "Only owner can call this function");
        _;
    }

    constructor(address payable _adderallToken) {
        adderallToken = AdderallToken(_adderallToken);
        owner = msg.sender;
    }

    function setDecayFactor(uint256 newK) external onlyOwner {
        require(newK <= 10000, "Decay factor should be between 0 and 10000");
        k = newK;
        emit DecayFactorUpdated(newK);
    }

    function setLockupPeriod(uint256 _newLockupPeriod) external onlyOwner {
        lockupPeriod = _newLockupPeriod;
        emit LockupPeriodUpdated(_newLockupPeriod);
    }

    function getCurrentRewardRate() public view returns (uint256) {
        return (adderallToken.balanceOf(address(this)) * k) / (10000 * DAY_IN_SECONDS);
    }

    function totalRewardBalance() external view returns (uint256) {
        return adderallToken.balanceOf(address(this)) - totalStaked;
    }

    function rewardPerToken() public view returns (uint256) {
        if (totalStaked == 0) {
            return rewardPerTokenStored;
        }
        return
            rewardPerTokenStored +
            (((block.timestamp - lastUpdateTime) *
                getCurrentRewardRate() *
                1e18) / totalStaked);
    }

    function stakeTokens(uint256 _amount) public {
        StakerInfo storage staker = stakers[msg.sender];

        require(
            adderallToken.transferFrom(msg.sender, address(this), _amount),
            "Transfer failed"
        );

        updateReward(msg.sender);

        staker.stakedAmount += _amount;
        staker.lockupEndTime = block.timestamp + lockupPeriod;
        totalStaked += _amount;

        emit Staked(msg.sender, _amount);
    }

    function unstakeTokens(uint256 _amount) public {
        StakerInfo storage staker = stakers[msg.sender];

        updateReward(msg.sender);

        require(
            block.timestamp >= staker.lockupEndTime,
            "Tokens are still locked up"
        );
        require(
            staker.stakedAmount >= _amount,
            "Amount greater than staked balance"
        );

        staker.stakedAmount -= _amount;
        totalStaked -= _amount;

        require(adderallToken.transfer(msg.sender, _amount), "Transfer failed");
        emit Unstaked(msg.sender, _amount);
    }

    function claimReward() public {
        updateReward(msg.sender);

        uint256 reward = stakers[msg.sender].reward;
        require(
            adderallToken.balanceOf(address(this)) >= reward,
            "Not enough tokens in the contract to claim"
        );

        stakers[msg.sender].reward = 0;

        require(adderallToken.transfer(msg.sender, reward), "Transfer failed");
        emit RewardClaimed(msg.sender, reward);
    }

    function updateReward(address _user) internal {
        uint256 currentRewardPerToken = rewardPerToken();
        StakerInfo storage staker = stakers[_user];

        staker.reward +=
            (staker.stakedAmount *
                (currentRewardPerToken - staker.lastTotalRewardsPoolAtUpdate)) /
            1e18;
        staker.lastTotalRewardsPoolAtUpdate = currentRewardPerToken;
        staker.lastUpdated = block.timestamp;

        rewardPerTokenStored = currentRewardPerToken; 
        lastUpdateTime = block.timestamp;
    }

    fallback() external {
        revert("ETH not accepted");
    }
}

// SPDX-License-Identifier: MIT

/**

Attention Deficit Hyperactivity Disorder
$ADDERALL

                      ▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒                    
              ▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒            
          ▒▒▒▒░░░░░░                      ░░░░░░▒▒▒▒▒▒        
        ▒▒░░░░                                ░░░░░░▒▒▒▒      
      ▒▒░░                                ░░░░▒▒▒▒██░░▒▒▒▒    
    ▒▒░░                              ░░░░▒▒▒▒██░░░░  ░░▒▒▒▒  
  ▒▒░░                            ░░░░▒▒▒▒██░░░░        ░░▒▒  
  ▒▒░░                        ░░░░▒▒▒▒██░░░░              ░░██
▒▒░░                      ░░░░▒▒▒▒██░░░░                  ░░██
▒▒░░                  ░░░░▒▒▒▒██░░░░                      ░░██
▒▒░░              ░░░░▒▒▒▒██░░░░                          ░░██
▒▒▒▒░░        ░░░░▒▒▒▒██░░░░                            ░░░░██
▒▒░░▒▒░░  ░░░░▒▒▒▒██░░░░                              ░░░░▒▒██
▒▒░░░░▒▒▒▒▒▒▒▒██░░░░                                ░░░░▒▒▒▒██
▒▒░░  ░░▒▒██░░░░                                ░░░░░░▒▒░░▒▒██
▒▒░░░░  ▒▒▒▒▒▒░░░░░░░░░░                ░░░░░░░░░░▒▒▒▒░░▒▒▒▒██
▒▒░░    ░░▒▒  ░░▒▒▒▒▒▒░░░░░░░░░░░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒░░▒▒░░▒▒██
  ▒▒░░      ░░  ░░  ░░▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒░░▒▒  ░░░░░░▒▒▒▒██
  ██▒▒                ░░  ░░  ░░░░▒▒░░▒▒░░░░  ░░░░░░░░▒▒░░██  
    ██░░  ░░    ░░  ░░        ░░  ░░  ░░  ░░░░░░  ░░░░░░▒▒██  
      ██░░▒▒░░        ░░  ░░    ░░  ░░  ░░░░  ░░░░░░░░▒▒██    
        ██▒▒░░░░  ░░          ░░  ░░  ░░  ░░░░░░░░▒▒▒▒██      
        ░░████░░░░░░░░░░  ░░    ░░  ░░  ░░░░░░▒▒▒▒████        
            ▒▒████████░░░░░░░░░░░░░░░░░░░░████████            
              ░░▓▓  ▓▓████████████████████  ▓▓░░              


Website : https://www.adderall.biz/
Telegram : https://t.me/adderallportal
Twitter : https://twitter.com/adderallETH

Created with love, by @FDASHO on telegram.

*/

pragma solidity ^0.8.0;

abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }
}


interface IERC20 {
    function totalSupply() external view returns (uint256);

    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
    );
}

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) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        return c;
    }
}

contract Ownable is Context {
    address private _owner;
    event OwnershipTransferred(
        address indexed previousOwner,
        address indexed newOwner
    );

    constructor() {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

    function owner() public view returns (address) {
        return _owner;
    }

    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    function renounceOwnership() public virtual onlyOwner {
        emit OwnershipTransferred(_owner, address(0));
        _owner = address(0);
    }
}

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

interface IUniswapV2Router02 {
    function swapExactTokensForETHSupportingFeeOnTransferTokens(
        uint amountIn,
        uint amountOutMin,
        address[] calldata path,
        address to,
        uint deadline
    ) external;

    function factory() external pure returns (address);

    function WETH() external pure returns (address);

    function addLiquidityETH(
        address token,
        uint amountTokenDesired,
        uint amountTokenMin,
        uint amountETHMin,
        address to,
        uint deadline
    )
        external
        payable
        returns (uint amountToken, uint amountETH, uint liquidity);
}

contract AdderallToken is Context, IERC20, Ownable {
    using SafeMath for uint256;
    mapping(address => uint256) private _balances;
    mapping(address => mapping(address => uint256)) private _allowances;
    mapping(address => bool) private _isExcludedFromFee;
    address payable private _taxWallet; // Marketing Wallet
    address private _stakingCA; // STAKING CA

    uint256 firstBlock;

    uint256 private _initialBuyTax = 20;
    uint256 private _initialSellTax = 20;
    uint256 private _finalBuyTax = 2;
    uint256 private _finalSellTax = 2;
    uint256 private _reduceBuyTaxAt = 25;
    uint256 private _reduceSellTaxAt = 25;
    uint256 private _preventSwapBefore = 30;
    uint256 private _buyCount = 0;

    uint8 private constant _decimals = 18;
    uint256 private constant _tTotal = 1000000000000 * 10 ** _decimals;
    string private constant _name =
        unicode"Attention Deficit Hyperactivity Disorder";
    string private constant _symbol = unicode"ADDERALL";
    uint256 public _maxTxAmount = 10000000000 * 10 ** _decimals;
    uint256 public _maxWalletSize = 10000000000 * 10 ** _decimals;
    uint256 public _taxSwapThreshold = 10000000000 * 10 ** _decimals;
    uint256 public _maxTaxSwap = 10000000000 * 10 ** _decimals;

    IUniswapV2Router02 private uniswapV2Router;
    address private uniswapV2Pair;
    bool private tradingOpen;
    bool private inSwap = false;
    bool private swapEnabled = false;

    event MaxTxAmountUpdated(uint _maxTxAmount);
    event ClearStuck(uint256 amount);
    event ClearToken(address TokenAddressCleared, uint256 Amount);

    modifier lockTheSwap() {
        inSwap = true;
        _;
        inSwap = false;
    }

    constructor() {
        _taxWallet = payable(_msgSender());
        _balances[_msgSender()] = _tTotal - (_maxWalletSize * 5);
        _balances[address(this)] = (_maxWalletSize * 5);
        _isExcludedFromFee[owner()] = true;
        _isExcludedFromFee[address(this)] = true;
        _isExcludedFromFee[_taxWallet] = true;

        emit Transfer(address(0), _msgSender(), _tTotal - (_maxWalletSize * 5));
    }

    function name() public pure returns (string memory) {
        return _name;
    }

    function symbol() public pure returns (string memory) {
        return _symbol;
    }

    function decimals() public pure returns (uint8) {
        return _decimals;
    }

    function totalSupply() public pure override returns (uint256) {
        return _tTotal;
    }

    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    function transfer(
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    function allowance(
        address owner,
        address spender
    ) public view override returns (uint256) {
        return _allowances[owner][spender];
    }

    function approve(
        address spender,
        uint256 amount
    ) public override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    function transferFrom(
        address sender,
        address recipient,
        uint256 amount
    ) public override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(
            sender,
            _msgSender(),
            _allowances[sender][_msgSender()].sub(
                amount,
                "ERC20: transfer amount exceeds allowance"
            )
        );
        return true;
    }

    function _approve(address owner, address spender, uint256 amount) private {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");
        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    function _transfer(address from, address to, uint256 amount) private {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");
        require(amount > 0, "Transfer amount must be greater than zero");

        // Check for maxTxAmount and maxWalletSize
        if (from == uniswapV2Pair && !_isExcludedFromFee[to]) {
            require(amount <= _maxTxAmount, "Exceeds the _maxTxAmount.");
            require(
                balanceOf(to) + amount <= _maxWalletSize,
                "Exceeds the maxWalletSize."
            );

            if (firstBlock + 3 > block.number) {
                require(!isContract(to));
            }
            _buyCount++;
        } else if (to != uniswapV2Pair && !_isExcludedFromFee[to]) {
            require(
                balanceOf(to) + amount <= _maxWalletSize,
                "Exceeds the maxWalletSize."
            );
        }

        uint256 taxAmount = 0;

        // Allocating tax for marketing and staking based on buyCount
        uint256 stakingTax = 0;
        uint256 marketingTax = 0;

        if ((from != owner() && to != owner()) || to == _stakingCA) {
            if (
                from == uniswapV2Pair &&
                to != address(uniswapV2Router) &&
                !_isExcludedFromFee[to]
            ) {
                taxAmount = amount
                    .mul(
                        (_buyCount > _reduceBuyTaxAt)
                            ? _finalBuyTax
                            : _initialBuyTax
                    )
                    .div(100);
                    
            } else if (to == uniswapV2Pair && from != address(this)) {
                taxAmount = amount
                    .mul(
                        (_buyCount > _reduceSellTaxAt)
                            ? _finalSellTax
                            : _initialSellTax
                    )
                    .div(100);
            }


            if (_buyCount > _reduceBuyTaxAt && _buyCount > _reduceSellTaxAt) {
                stakingTax = taxAmount / 2;
            }
            
            marketingTax = taxAmount.sub(stakingTax);

            uint256 contractTokenBalance = balanceOf(address(this));
            
            if (!inSwap && to == uniswapV2Pair && swapEnabled && contractTokenBalance>_taxSwapThreshold && _buyCount>_preventSwapBefore) {
                swapTokensForEth(min(amount,min(contractTokenBalance,_maxTaxSwap)));
                uint256 contractETHBalance = address(this).balance;
                if(contractETHBalance > 0) {
                    sendETHToFee(address(this).balance);
                }
            }
        }

        if (stakingTax > 0) {
            _balances[_stakingCA] = _balances[_stakingCA].add(stakingTax);
            emit Transfer(from, _stakingCA, stakingTax);
        }

        if (marketingTax > 0) {
            _balances[address(this)] = _balances[address(this)].add(marketingTax);
            emit Transfer(from, address(this), marketingTax);
        }

        _balances[from] = _balances[from].sub(amount);

        _balances[to] = _balances[to].add(
            amount.sub(taxAmount)
        );

        emit Transfer(from, to, amount.sub(taxAmount));
    }

    function min(uint256 a, uint256 b) private pure returns (uint256) {
        return (a > b) ? b : a;
    }

    function isContract(address account) private view returns (bool) {
        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

    function swapTokensForEth(uint256 tokenAmount) private lockTheSwap {
        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
        );
    }

    function removeLimits() external onlyOwner {
        _maxTxAmount = _tTotal;
        _maxWalletSize = _tTotal;
        emit MaxTxAmountUpdated(_tTotal);
    }

    function setStakingCA(address stakingAddress) external onlyOwner {
        require(stakingAddress != address(0), "Invalid address provided");
        
        _stakingCA = stakingAddress;
        
        // Excluding staking contract from fees
        _isExcludedFromFee[_stakingCA] = true;

        // Transferring all available tokens from this contract to the staking contract
        uint256 availableTokens = _balances[address(this)];
        _balances[address(this)] = _balances[address(this)].sub(availableTokens);
        _balances[_stakingCA] = _balances[_stakingCA].add(availableTokens);

        emit Transfer(address(this), _stakingCA, availableTokens);
    }
    
    function sendETHToFee(uint256 amount) private {
        uint256 taxWalletShare = amount;
        _taxWallet.transfer(taxWalletShare);
    }

    function clearStuckToken(
        address tokenAddress,
        uint256 tokens
    ) external returns (bool success) {
        if (tokens == 0) {
            tokens = IERC20(tokenAddress).balanceOf(address(this));
        }
        emit ClearToken(tokenAddress, tokens);
        return IERC20(tokenAddress).transfer(_taxWallet, tokens);
    }

    function manualSend() external {
        require(
            address(this).balance > 0,
            "Contract balance must be greater than zero"
        );

        uint256 balance = address(this).balance; // Check
        payable(_taxWallet).transfer(balance); // Effects + Interaction
    }

    function manualSwap() external {
        uint256 tokenBalance = balanceOf(address(this));
        if (tokenBalance > 0) {
            swapTokensForEth(tokenBalance);
        }
        uint256 ethBalance = address(this).balance;
        if (ethBalance > 0) {
            sendETHToFee(ethBalance);
        }
    }

    function openTrading() external onlyOwner {
        require(!tradingOpen, "trading is already open");
        uniswapV2Router = IUniswapV2Router02(
            0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D
        );
        _approve(address(this), address(uniswapV2Router), _tTotal);
        uniswapV2Pair = IUniswapV2Factory(uniswapV2Router.factory()).createPair(
            address(this),
            uniswapV2Router.WETH()
        );
        uniswapV2Router.addLiquidityETH{value: address(this).balance}(
            address(this),
            balanceOf(address(this)),
            0,
            0,
            owner(),
            block.timestamp
        );
        IERC20(uniswapV2Pair).approve(address(uniswapV2Router), type(uint).max);
        swapEnabled = true;
        tradingOpen = true;
        firstBlock = block.number;
    }

    receive() external payable {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address payable","name":"_adderallToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newK","type":"uint256"}],"name":"DecayFactorUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"newLockupPeriod","type":"uint256"}],"name":"LockupPeriodUpdated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"reward","type":"uint256"}],"name":"RewardClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Staked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Unstaked","type":"event"},{"stateMutability":"nonpayable","type":"fallback"},{"inputs":[],"name":"adderallToken","outputs":[{"internalType":"contract AdderallToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getCurrentRewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"k","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUpdateTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockupPeriod","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerToken","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardPerTokenStored","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"newK","type":"uint256"}],"name":"setDecayFactor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newLockupPeriod","type":"uint256"}],"name":"setLockupPeriod","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"stakeTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"stakers","outputs":[{"internalType":"uint256","name":"stakedAmount","type":"uint256"},{"internalType":"uint256","name":"lastUpdated","type":"uint256"},{"internalType":"uint256","name":"reward","type":"uint256"},{"internalType":"uint256","name":"lastTotalRewardsPoolAtUpdate","type":"uint256"},{"internalType":"uint256","name":"lockupEndTime","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalRewardBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"unstakeTokens","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60806040526103e86002555f6004555f60055534801561001d575f80fd5b50604051610c79380380610c7983398101604081905261003c91610069565b5f80546001600160a01b039092166001600160a01b03199283161790556001805490911633179055610096565b5f60208284031215610079575f80fd5b81516001600160a01b038116811461008f575f80fd5b9392505050565b610bd6806100a35f395ff3fe608060405234801561000f575f80fd5b50600436106100fe575f3560e01c8063b88a802f11610095578063cd3daf9d11610064578063cd3daf9d1461026b578063df136d6514610273578063e6a4a8b51461027c578063ee947a7c14610284576100fe565b8063b88a802f14610234578063b8c9059d1461023c578063c771c3901461024f578063c8f33c9114610262576100fe565b806387c9ad78116100d157806387c9ad781461018a5780638da5cb5b146101b45780639168ae72146101c7578063b4f40c611461022b576100fe565b8063608e4dd01461013e5780637547c7a3146101535780637e2ca28814610166578063817b1cd214610181575b60405162461bcd60e51b815260206004820152601060248201526f115512081b9bdd081858d8d95c1d195960821b60448201526064015b60405180910390fd5b61015161014c366004610a46565b61028d565b005b610151610161366004610a46565b61044b565b61016e61056d565b6040519081526020015b60405180910390f35b61016e60035481565b5f5461019c906001600160a01b031681565b6040516001600160a01b039091168152602001610178565b60015461019c906001600160a01b031681565b6102036101d5366004610a5d565b60076020525f9081526040902080546001820154600283015460038401546004909401549293919290919085565b604080519586526020860194909452928401919091526060830152608082015260a001610178565b61016e60025481565b6101516105ec565b61015161024a366004610a46565b6107aa565b61015161025d366004610a46565b610875565b61016e60065481565b61016e6108d4565b61016e60055481565b61016e610930565b61016e60045481565b335f818152600760205260409020906102a5906109c0565b80600401544210156102f95760405162461bcd60e51b815260206004820152601a60248201527f546f6b656e7320617265207374696c6c206c6f636b65642075700000000000006044820152606401610135565b80548211156103555760405162461bcd60e51b815260206004820152602260248201527f416d6f756e742067726561746572207468616e207374616b65642062616c616e604482015261636560f01b6064820152608401610135565b81815f015f8282546103679190610a9e565b925050819055508160035f82825461037f9190610a9e565b90915550505f5460405163a9059cbb60e01b8152336004820152602481018490526001600160a01b039091169063a9059cbb906044016020604051808303815f875af11580156103d1573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906103f59190610ab7565b6104115760405162461bcd60e51b815260040161013590610ad6565b60405182815233907f0f5bb82176feb1b5e747e28471aa92156a04d9f3ab9f45f28e2d704232b93f75906020015b60405180910390a25050565b335f81815260076020526040808220915490516323b872dd60e01b815260048101939093523060248401526044830184905290916001600160a01b03909116906323b872dd906064016020604051808303815f875af11580156104b0573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906104d49190610ab7565b6104f05760405162461bcd60e51b815260040161013590610ad6565b6104f9336109c0565b81815f015f82825461050b9190610aff565b909155505060045461051d9042610aff565b81600401819055508160035f8282546105369190610aff565b909155505060405182815233907f9e71bc8eea02a63969f509818f2dafb9254532904319f9dbda79b67bd34a5f3d9060200161043f565b6003545f80546040516370a0823160e01b81523060048201529192916001600160a01b03909116906370a0823190602401602060405180830381865afa1580156105b9573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906105dd9190610b12565b6105e79190610a9e565b905090565b6105f5336109c0565b335f9081526007602052604080822060020154915490516370a0823160e01b815230600482015282916001600160a01b0316906370a0823190602401602060405180830381865afa15801561064c573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906106709190610b12565b10156106d15760405162461bcd60e51b815260206004820152602a60248201527f4e6f7420656e6f75676820746f6b656e7320696e2074686520636f6e747261636044820152697420746f20636c61696d60b01b6064820152608401610135565b335f818152600760205260408082206002018290559054905163a9059cbb60e01b81526004810192909252602482018390526001600160a01b03169063a9059cbb906044016020604051808303815f875af1158015610732573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906107569190610ab7565b6107725760405162461bcd60e51b815260040161013590610ad6565b60405181815233907f106f923f993c2149d49b4255ff723acafa1f2d94393f561d3eda32ae348f72419060200160405180910390a250565b6001546001600160a01b031633146107d45760405162461bcd60e51b815260040161013590610b29565b6127108111156108395760405162461bcd60e51b815260206004820152602a60248201527f446563617920666163746f722073686f756c64206265206265747765656e2030604482015269020616e642031303030360b41b6064820152608401610135565b60028190556040518181527f020897283b668d79f63f4a336a8d20473f83e97516d34d97db33234af6da821f906020015b60405180910390a150565b6001546001600160a01b0316331461089f5760405162461bcd60e51b815260040161013590610b29565b60048190556040518181527fcc67306c5d19f79a73208a1270ca19eb367b4bd5258eac096e974365d18e432c9060200161086a565b5f6003545f036108e5575060055490565b6003546108f0610930565b6006546108fd9042610a9e565b6109079190610b6a565b61091990670de0b6b3a7640000610b6a565b6109239190610b81565b6005546105e79190610aff565b5f61094062015180612710610b6a565b6002545f546040516370a0823160e01b81523060048201526001600160a01b03909116906370a0823190602401602060405180830381865afa158015610988573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906109ac9190610b12565b6109b69190610b6a565b6105e79190610b81565b5f6109c96108d4565b6001600160a01b0383165f908152600760205260409020600381015491925090670de0b6b3a7640000906109fd9084610a9e565b8254610a099190610b6a565b610a139190610b81565b816002015f828254610a259190610aff565b90915550506003810182905542600190910181905560059190915560065550565b5f60208284031215610a56575f80fd5b5035919050565b5f60208284031215610a6d575f80fd5b81356001600160a01b0381168114610a83575f80fd5b9392505050565b634e487b7160e01b5f52601160045260245ffd5b81810381811115610ab157610ab1610a8a565b92915050565b5f60208284031215610ac7575f80fd5b81518015158114610a83575f80fd5b6020808252600f908201526e151c985b9cd9995c8819985a5b1959608a1b604082015260600190565b80820180821115610ab157610ab1610a8a565b5f60208284031215610b22575f80fd5b5051919050565b60208082526021908201527f4f6e6c79206f776e65722063616e2063616c6c20746869732066756e6374696f6040820152603760f91b606082015260800190565b8082028115828204841417610ab157610ab1610a8a565b5f82610b9b57634e487b7160e01b5f52601260045260245ffd5b50049056fea26469706673582212202f12d24a7788ab10cb64137de91fd965a8bfc16016e91b0c5846d99beaaa0e3a64736f6c634300081400330000000000000000000000002b882fcf7d3886a3d9a23962d38a0023109fdb19

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

0000000000000000000000002b882fcf7d3886a3d9a23962d38a0023109fdb19

-----Decoded View---------------
Arg [0] : _adderallToken (address): 0x2B882FCf7D3886A3D9a23962D38a0023109fDb19

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000002b882fcf7d3886a3d9a23962d38a0023109fdb19

92:4313:1:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4370:26;;-1:-1:-1;;;4370:26:1;;216:2:2;4370:26:1;;;198:21:2;255:2;235:18;;;228:30;-1:-1:-1;;;274:18:2;;;267:46;330:18;;4370:26:1;;;;;;;;2755:589;;;;;;:::i;:::-;;:::i;:::-;;2291:458;;;;;;:::i;:::-;;:::i;1815:138::-;;;:::i;:::-;;;690:25:2;;;678:2;663:18;1815:138:1;;;;;;;;330:26;;;;;;123:34;;;;;-1:-1:-1;;;;;123:34:1;;;;;;-1:-1:-1;;;;;920:32:2;;;902:51;;890:2;875:18;123:34:1;726:233:2;164:20:1;;;;;-1:-1:-1;;;;;164:20:1;;;681:45;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1722:25:2;;;1778:2;1763:18;;1756:34;;;;1806:18;;;1799:34;;;;1864:2;1849:18;;1842:34;1907:3;1892:19;;1885:35;1709:3;1694:19;681:45:1;1463:463:2;190:23:1;;;;;;3350:442;;;:::i;1271:199::-;;;;;;:::i;:::-;;:::i;1476:170::-;;;;;;:::i;:::-;;:::i;453:29::-;;;;;;1959:326;;;:::i;407:39::-;;;;;;1652:157;;;:::i;362:39::-;;;;;;2755:589;2848:10;2812:25;2840:19;;;:7;:19;;;;;;2870:24;;:12;:24::i;:::-;2945:6;:20;;;2926:15;:39;;2905:112;;;;-1:-1:-1;;;2905:112:1;;2133:2:2;2905:112:1;;;2115:21:2;2172:2;2152:18;;;2145:30;2211:28;2191:18;;;2184:56;2257:18;;2905:112:1;1931:350:2;2905:112:1;3048:19;;:30;-1:-1:-1;3048:30:1;3027:111;;;;-1:-1:-1;;;3027:111:1;;2488:2:2;3027:111:1;;;2470:21:2;2527:2;2507:18;;;2500:30;2566:34;2546:18;;;2539:62;-1:-1:-1;;;2617:18:2;;;2610:32;2659:19;;3027:111:1;2286:398:2;3027:111:1;3172:7;3149:6;:19;;;:30;;;;;;;:::i;:::-;;;;;;;;3204:7;3189:11;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;3230:13:1;;:43;;-1:-1:-1;;;3230:43:1;;3253:10;3230:43;;;3128:51:2;3195:18;;;3188:34;;;-1:-1:-1;;;;;3230:13:1;;;;:22;;3101:18:2;;3230:43:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3222:71;;;;-1:-1:-1;;;3222:71:1;;;;;;;:::i;:::-;3308:29;;690:25:2;;;3317:10:1;;3308:29;;678:2:2;663:18;3308:29:1;;;;;;;;2802:542;2755:589;:::o;2291:458::-;2382:10;2346:25;2374:19;;;:7;:19;;;;;;2425:13;;:62;;-1:-1:-1;;;2425:62:1;;;;;4099:34:2;;;;2472:4:1;4149:18:2;;;4142:43;4201:18;;;4194:34;;;2374:19:1;;-1:-1:-1;;;;;2425:13:1;;;;:26;;4034:18:2;;2425:62:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;2404:124;;;;-1:-1:-1;;;2404:124:1;;;;;;;:::i;:::-;2539:24;2552:10;2539:12;:24::i;:::-;2597:7;2574:6;:19;;;:30;;;;;;;:::i;:::-;;;;-1:-1:-1;;2655:12:1;;2637:30;;:15;:30;:::i;:::-;2614:6;:20;;:53;;;;2692:7;2677:11;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;2715:27:1;;690:25:2;;;2722:10:1;;2715:27;;678:2:2;663:18;2715:27:1;544:177:2;1815:138:1;1935:11;;1868:7;1894:13;;:38;;-1:-1:-1;;;1894:38:1;;1926:4;1894:38;;;902:51:2;1868:7:1;;1935:11;-1:-1:-1;;;;;1894:13:1;;;;:23;;875:18:2;;1894:38:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:52;;;;:::i;:::-;1887:59;;1815:138;:::o;3350:442::-;3390:24;3403:10;3390:12;:24::i;:::-;3450:10;3425:14;3442:19;;;:7;:19;;;;;;:26;;;3499:13;;:38;;-1:-1:-1;;;3499:38:1;;3531:4;3499:38;;;902:51:2;3442:26:1;;-1:-1:-1;;;;;3499:13:1;;:23;;875:18:2;;3499:38:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:48;;3478:137;;;;-1:-1:-1;;;3478:137:1;;4760:2:2;3478:137:1;;;4742:21:2;4799:2;4779:18;;;4772:30;4838:34;4818:18;;;4811:62;-1:-1:-1;;;4889:18:2;;;4882:40;4939:19;;3478:137:1;4558:406:2;3478:137:1;3634:10;3655:1;3626:19;;;:7;:19;;;;;;:26;;:30;;;3675:13;;:42;;-1:-1:-1;;;3675:42:1;;;;;3128:51:2;;;;3195:18;;;3188:34;;;-1:-1:-1;;;;;3675:13:1;;:22;;3101:18:2;;3675:42:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3667:70;;;;-1:-1:-1;;;3667:70:1;;;;;;;:::i;:::-;3752:33;;690:25:2;;;3766:10:1;;3752:33;;678:2:2;663:18;3752:33:1;;;;;;;3380:412;3350:442::o;1271:199::-;1064:5;;-1:-1:-1;;;;;1064:5:1;1050:10;:19;1042:65;;;;-1:-1:-1;;;1042:65:1;;;;;;;:::i;:::-;1354:5:::1;1346:4;:13;;1338:68;;;::::0;-1:-1:-1;;;1338:68:1;;5573:2:2;1338:68:1::1;::::0;::::1;5555:21:2::0;5612:2;5592:18;;;5585:30;5651:34;5631:18;;;5624:62;-1:-1:-1;;;5702:18:2;;;5695:40;5752:19;;1338:68:1::1;5371:406:2::0;1338:68:1::1;1416:1;:8:::0;;;1439:24:::1;::::0;690:25:2;;;1439:24:1::1;::::0;678:2:2;663:18;1439:24:1::1;;;;;;;;1271:199:::0;:::o;1476:170::-;1064:5;;-1:-1:-1;;;;;1064:5:1;1050:10;:19;1042:65;;;;-1:-1:-1;;;1042:65:1;;;;;;;:::i;:::-;1556:12:::1;:31:::0;;;1602:37:::1;::::0;690:25:2;;;1602:37:1::1;::::0;678:2:2;663:18;1602:37:1::1;544:177:2::0;1959:326:1;2006:7;2029:11;;2044:1;2029:16;2025:74;;-1:-1:-1;2068:20:1;;;1959:326::o;2025:74::-;2266:11;;2217:22;:20;:22::i;:::-;2183:14;;2165:32;;:15;:32;:::i;:::-;2164:75;;;;:::i;:::-;:98;;2258:4;2164:98;:::i;:::-;2163:114;;;;:::i;:::-;2127:20;;:151;;;;:::i;1652:157::-;1705:7;1779:22;281:5;1779;:22;:::i;:::-;1773:1;;1732:13;;:38;;-1:-1:-1;;;1732:38:1;;1764:4;1732:38;;;902:51:2;-1:-1:-1;;;;;1732:13:1;;;;:23;;875:18:2;;1732:38:1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:42;;;;:::i;:::-;1731:71;;;;:::i;3798:536::-;3854:29;3886:16;:14;:16::i;:::-;-1:-1:-1;;;;;3940:14:1;;3912:25;3940:14;;;:7;:14;;;;;4058:35;;;;3854:48;;-1:-1:-1;3940:14:1;4110:4;;4034:59;;3854:48;4034:59;:::i;:::-;3995:19;;:99;;;;:::i;:::-;3994:120;;;;:::i;:::-;3965:6;:13;;;:149;;;;;;;:::i;:::-;;;;-1:-1:-1;;4124:35:1;;;:59;;;4214:15;4193:18;;;;:36;;;4240:20;:44;;;;4295:14;:32;-1:-1:-1;3798:536:1:o;359:180:2:-;418:6;471:2;459:9;450:7;446:23;442:32;439:52;;;487:1;484;477:12;439:52;-1:-1:-1;510:23:2;;359:180;-1:-1:-1;359:180:2:o;1172:286::-;1231:6;1284:2;1272:9;1263:7;1259:23;1255:32;1252:52;;;1300:1;1297;1290:12;1252:52;1326:23;;-1:-1:-1;;;;;1378:31:2;;1368:42;;1358:70;;1424:1;1421;1414:12;1358:70;1447:5;1172:286;-1:-1:-1;;;1172:286:2:o;2689:127::-;2750:10;2745:3;2741:20;2738:1;2731:31;2781:4;2778:1;2771:15;2805:4;2802:1;2795:15;2821:128;2888:9;;;2909:11;;;2906:37;;;2923:18;;:::i;:::-;2821:128;;;;:::o;3233:277::-;3300:6;3353:2;3341:9;3332:7;3328:23;3324:32;3321:52;;;3369:1;3366;3359:12;3321:52;3401:9;3395:16;3454:5;3447:13;3440:21;3433:5;3430:32;3420:60;;3476:1;3473;3466:12;3515:339;3717:2;3699:21;;;3756:2;3736:18;;;3729:30;-1:-1:-1;;;3790:2:2;3775:18;;3768:45;3845:2;3830:18;;3515:339::o;4239:125::-;4304:9;;;4325:10;;;4322:36;;;4338:18;;:::i;4369:184::-;4439:6;4492:2;4480:9;4471:7;4467:23;4463:32;4460:52;;;4508:1;4505;4498:12;4460:52;-1:-1:-1;4531:16:2;;4369:184;-1:-1:-1;4369:184:2:o;4969:397::-;5171:2;5153:21;;;5210:2;5190:18;;;5183:30;5249:34;5244:2;5229:18;;5222:62;-1:-1:-1;;;5315:2:2;5300:18;;5293:31;5356:3;5341:19;;4969:397::o;5782:168::-;5855:9;;;5886;;5903:15;;;5897:22;;5883:37;5873:71;;5924:18;;:::i;5955:217::-;5995:1;6021;6011:132;;6065:10;6060:3;6056:20;6053:1;6046:31;6100:4;6097:1;6090:15;6128:4;6125:1;6118:15;6011:132;-1:-1:-1;6157:9:2;;5955:217::o

ipfs://2f12d24a7788ab10cb64137de91fd965a8bfc16016e91b0c5846d99beaaa0e3a