Skip to main content
PulseScanner.io

Address

0xabbb7c5727a328b0cbce7f3fae4e1ff5fa181dce
Current Holdings
$0.00
TXs sent
not counted
First Active
2026-05-30
block 26,656,204
Last Active
108 days ago
block 26,656,209
Funded By
not identified

Net worth historyi

No net-worth snapshots recorded yet
exact matchPlainERC20Tokensolc 0.8.31+commit.fd3a2265runtime exact · creation exact
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.24;

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Ownable} from "@openzeppelin/contracts/access/Ownable.sol";

import {Helpers} from "./interfaces/TokenTypes.sol";

/// @notice Fixed-supply non-tax launch token used by the Cabal/Pump curve.
/// @dev Keeps the small factory-facing surface that TokenFactoryTax already
///      expects, but does not include tax, trading-gate, or swap logic.
contract PlainERC20Token is ERC20, Ownable {
    address public constant DEAD = 0x000000000000000000000000000000000000dEaD;

    uint256 public immutable initialSupply;
    address public immutable factory;

    address public minter;
    bool public mintable;
    bool public mintingFinalized;
    bool public mintableInitialized;

    error MintableAlreadyInitialized();
    error MintingAlreadyFinalized();
    error MintingNotEnabled();
    error NotFactory();
    error NotMinter();

    event MinterChanged(address indexed previousMinter, address indexed newMinter);
    event MintableInitialized(address indexed minter);
    event Minted(address indexed to, uint256 amount);
    event MintingFinalized();

    constructor(
        string memory name_,
        string memory symbol_,
        address owner_,
        address mintTo_,
        uint256 initialSupply_,
        uint256 burnOnDeployPct_,
        address vestingContract_,
        uint256 vestAmount_,
        address factory_
    ) ERC20(name_, symbol_) Ownable(owner_) {
        require(owner_ != address(0), "Invalid owner");
        require(mintTo_ != address(0), "Invalid mint to");
        require(factory_ != address(0), "Invalid factory");
        require(burnOnDeployPct_ <= 9000, "Burn > 90%");

        initialSupply = initialSupply_;
        factory = factory_;

        _mint(mintTo_, initialSupply_);

        if (burnOnDeployPct_ > 0) {
            _burn(mintTo_, (initialSupply_ * burnOnDeployPct_) / 10_000);
        }

        if (vestAmount_ > 0) {
            require(vestingContract_ != address(0), "Invalid vesting");
            _transfer(mintTo_, vestingContract_, vestAmount_);
        }
    }

    function getTaxes() external pure returns (Helpers.Tax[] memory taxes) {
        taxes = new Helpers.Tax[](0);
    }

    function initMintable(address minter_) external {
        if (msg.sender != factory) revert NotFactory();
        if (mintableInitialized) revert MintableAlreadyInitialized();
        mintableInitialized = true;
        mintable = true;
        minter = minter_;
        emit MintableInitialized(minter_);
        emit MinterChanged(address(0), minter_);
    }

    function mint(address to, uint256 amount) external {
        if (!mintable || mintingFinalized) revert MintingNotEnabled();
        if (msg.sender != minter) revert NotMinter();
        _mint(to, amount);
        emit Minted(to, amount);
    }

    function setMinter(address newMinter) external onlyOwner {
        if (!mintable) revert MintingNotEnabled();
        if (mintingFinalized) revert MintingAlreadyFinalized();
        address previous = minter;
        minter = newMinter;
        emit MinterChanged(previous, newMinter);
    }

    function finalizeMinting() external onlyOwner {
        if (mintingFinalized) revert MintingAlreadyFinalized();
        mintingFinalized = true;
        if (minter != address(0)) {
            emit MinterChanged(minter, address(0));
            minter = address(0);
        }
        emit MintingFinalized();
    }

    function _update(address from, address to, uint256 value) internal override {
        if (to == DEAD && from != address(0)) {
            super._update(from, address(0), value);
            return;
        }
        super._update(from, to, value);
    }
}