P-FEN is the receipt path into locked FEN claims.

constructor(
        IPresaleFEN fen_,
        IERC20Metadata paymentToken_,
        address treasury_
    ) ERC20('Presale FEN Receipt', 'P-FEN') {
        if (block.chainid != FENCHAIN_CHAIN_ID) {
            revert WrongFenchain(block.chainid, FENCHAIN_CHAIN_ID);
        }
        if (address(fen_) == address(0) || address(paymentToken_) == address(0)) revert ZeroAddress();
        if (treasury_ == address(0)) revert ZeroAddress();
        address configuredLaunchController = fen_.launchController();
        if (configuredLaunchController != treasury_) {
            revert InvalidLaunchController(configuredLaunchController, treasury_);
        }

        uint8 decimals_ = paymentToken_.decimals();
        if (decimals_ < 2 || decimals_ > 30) revert BadStablecoinDecimals(decimals_);

        fen = fen_;
        paymentToken = IERC20(address(paymentToken_));
        treasury = treasury_;
        paymentTokenDecimals = decimals_;

        uint256 unit = 10 ** uint256(decimals_);
        _stages[0] = Stage({allocation: 2_500_000 ether, sold: 0, price: unit / 100});
        _stages[1] = Stage({allocation: 5_000_000 ether, sold: 0, price: (unit * 2) / 100});
        _stages[2] = Stage({allocation: 7_500_000 ether, sold: 0, price: (unit * 3) / 100});
        for (uint256 i = 3; i < 14; i++) {
            _stages[i] = Stage({allocation: 15_000_000 ether, sold: 0, price: (unit * (i + 1)) / 100});
        }
        _stages[14] = Stage({allocation: 20_000_000 ether, sold: 0, price: (unit * 15) / 100});

        uint256 totalAllocation = 0;
        for (uint256 i = 0; i < STAGE_COUNT; i++) {
            totalAllocation += _stages[i].allocation;
        }
        if (totalAllocation != PRESALE_ALLOCATION) {
            revert ReserveInvariantBroken(totalAllocation, PRESALE_ALLOCATION);
        }
    }

function buyPFEN(
        uint256 pfenAmount,
        uint256 expectedStage,
        uint256 maxStablecoinAmount,
        uint256 deadline
    ) external nonReentrant {
        if (!opened) revert PresaleNotOpen();
        if (soldOutAt != 0) revert PresaleAlreadyFinalized();
        // slither-disable-next-line timestamp
        if (block.timestamp >= saleEnd) revert PresaleClosed(saleEnd);
        // slither-disable-next-line timestamp
        if (block.timestamp > deadline) revert PurchaseExpired(deadline, block.timestamp);
        if (pfenAmount == 0) revert ZeroAmount();
        _requireActiveReserve();

        uint256 stageIndex = currentStage;
        if (stageIndex != expectedStage) revert StageChanged(expectedStage, stageIndex);

        Stage storage activeStage = _stages[stageIndex];
        uint256 remaining = activeStage.allocation - activeStage.sold;
        if (pfenAmount > remaining) {
            revert StageAllocationExceeded(stageIndex, pfenAmount, remaining);
        }

        uint256 stablecoinAmount = quotePFEN(stageIndex, pfenAmount);
        if (stablecoinAmount > maxStablecoinAmount) {
            revert PaymentExceedsMaximum(stablecoinAmount, maxStablecoinAmount);
        }
        uint256 treasuryBalanceBefore = paymentToken.balanceOf(treasury);
        paymentToken.safeTransferFrom(msg.sender, treasury, stablecoinAmount);
        uint256 treasuryBalanceAfter = paymentToken.balanceOf(treasury);
        uint256 stablecoinReceived =
            treasuryBalanceAfter >= treasuryBalanceBefore ? treasuryBalanceAfter - treasuryBalanceBefore : 0;
        if (stablecoinReceived < stablecoinAmount) {
            revert TreasuryPaymentShortfall(stablecoinAmount, stablecoinReceived);
        }

        activeStage.sold += pfenAmount;
        totalSoldPFEN += pfenAmount;
        totalStablecoinRaised += stablecoinReceived;
        purchasedPFEN[msg.sender] += pfenAmount;

        emit PaymentForwarded(
            msg.sender,
            address(paymentToken),
            stablecoinAmount,
            stablecoinReceived,
            treasury
        );

        _mint(msg.sender, pfenAmount);
        emit PFENPurchased(msg.sender, stageIndex, pfenAmount, stablecoinReceived, treasury);

        _advanceStage();

        if (totalSoldPFEN == PRESALE_ALLOCATION) {
            _recordSellout(block.timestamp);
        }
    }

function claim() external nonReentrant returns (uint256 amount) {
        amount = claimable(msg.sender);
        // slither-disable-next-line incorrect-equality,timestamp
        if (amount == 0) revert NoClaimableFEN(msg.sender);

        uint256 reserveBeforeClaim = fen.balanceOf(address(this));
        uint256 requiredBeforeClaim = outstandingFEN();
        if (reserveBeforeClaim < requiredBeforeClaim) {
            revert ReserveInvariantBroken(reserveBeforeClaim, requiredBeforeClaim);
        }

        claimedFEN[msg.sender] += amount;
        totalClaimedFEN += amount;
        _burn(msg.sender, amount);
        fen.safeTransfer(msg.sender, amount);

        uint256 reserveAfterClaim = fen.balanceOf(address(this));
        uint256 requiredAfterClaim = outstandingFEN();
        if (reserveAfterClaim < requiredAfterClaim) {
            revert ReserveInvariantBroken(reserveAfterClaim, requiredAfterClaim);
        }
        emit FENClaimed(msg.sender, amount, amount);
    }

function claimable(address account) public view returns (uint256) {
        uint256 resolvedClaimStart = claimStart();
        if (resolvedClaimStart == 0 || block.timestamp < resolvedClaimStart) return 0;

        uint256 periods = ((block.timestamp - resolvedClaimStart) / RELEASE_INTERVAL) + 1;
        uint256 unlockedBasisPoints =
            periods >= FINAL_RELEASE_PERIOD ? BPS : periods * RELEASE_BPS;
        uint256 unlocked = (purchasedPFEN[account] * unlockedBasisPoints) / BPS;
        uint256 alreadyClaimed = claimedFEN[account];
        if (unlocked <= alreadyClaimed) return 0;
        return unlocked - alreadyClaimed;
    }

function approve(address, uint256) public pure override returns (bool) {
        revert PFENNonTransferable();
    }

function transfer(address, uint256) public pure override returns (bool) {
        revert PFENNonTransferable();
    }

function transferFrom(address, address, uint256) public pure override returns (bool) {
        revert PFENNonTransferable();
    }

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