blast code with sec

pragma solidity ^0.8.0;

import "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import "@openzeppelin/contracts/access/Ownable.sol";
import "@openzeppelin/contracts/utils/math/SafeMath.sol";

contract BondingCurveNFT is ERC721, Ownable {
    using SafeMath for uint256;

    // Bonding curve parameters
    uint256 public constant INITIAL_SUPPLY = 1000;
    uint256 public INITIAL_PRICE = 1 ether;
    uint256 public SLOPE_NUMERATOR = 1;
    uint256 public SLOPE_DENOMINATOR = 100;

    // Event emitted upon NFT minting
    event Mint(address indexed to, uint256 amount);

    // Mapping to track token balances
    mapping(address => uint256) public balances;

    // Constructor
    constructor(string memory _name, string memory _symbol) ERC721(_name, _symbol) {
        // Mint initial supply to contract owner
        balances[owner()] = INITIAL_SUPPLY;
    }

    // Calculate the minting price based on bonding curve equation
    function calculateMintPrice(uint256 _amount) public view returns (uint256) {
        return INITIAL_PRICE.add(getPriceChange(_amount));
    }

    // Get the change in price for a given amount of tokens
    function getPriceChange(uint256 _amount) public view returns (uint256) {
        return (_amount.mul(SLOPE_NUMERATOR)).div(SLOPE_DENOMINATOR);
    }

    // Mint NFTs by sending the required amount of cryptocurrency
    function mint(uint256 _amount) external payable {
        uint256 price = calculateMintPrice(_amount);
        require(msg.value >= price, "Insufficient funds");

        // Transfer tokens to the sender
        balances[msg.sender] = balances[msg.sender].add(_amount);

        // Emit mint event
        emit Mint(msg.sender, _amount);
    }

    // Adjust bonding curve parameters (e.g., slope, initial price)
    function adjustBondingCurve(uint256 _initialPrice, uint256 _slopeNumerator, uint256 _slopeDenominator) external onlyOwner {
        // Update bonding curve parameters
        INITIAL_PRICE = _initialPrice;
        SLOPE_NUMERATOR = _slopeNumerator;
        SLOPE_DENOMINATOR = _slopeDenominator;
    }

    // Get the balance of tokens for a given address
    function balanceOf(address _owner) external view returns (uint256) {
        return balances[_owner];
    }

    // Function to transfer tokens to another address
    function transfer(address _to, uint256 _amount) external {
        require(balances[msg.sender] >= _amount, "Insufficient balance");
        balances[msg.sender] = balances[msg.sender].sub(_amount);
        balances[_to] = balances[_to].add(_amount);
    }

    // Function to get the contract owner
    function owner() public view returns (address) {
        return owner();
    }

    // Fallback function to receive Ether
    receive() external payable {}
}