Issue with my own code

[arefxv]

Guys, I'm having an issue with this code.
The mint functions are failing with an error.
I'd really appreciate it if someone could help me out!

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

import { ERC721 } from "@openzeppelin/contracts/token/ERC721/ERC721.sol";
import { Ownable } from "@openzeppelin/contracts/access/Ownable.sol";
import { IPAssetRegistry } from "@storyprotocol/core/registries/IPAssetRegistry.sol";
import { ECDSA } from "@openzeppelin/contracts/utils/cryptography/ECDSA.sol";
import { MessageHashUtils } from "@openzeppelin/contracts/utils/cryptography/MessageHashUtils.sol";
import { ILicensingModule } from "@story-protocol/protocol-core/contracts/interfaces/modules/licensing/ILicensingModule.sol";
import { IERC721Receiver } from "@openzeppelin/contracts/token/ERC721/IERC721Receiver.sol";
import { CoreMetadataModule } from "@story-protocol/protocol-core/contracts/modules/metadata/CoreMetadataModule.sol";
import "./StringUtils.sol";

contract testpp is ERC721, Ownable, IERC721Receiver {
    IPAssetRegistry public immutable IP_ASSET_REGISTRY;
    ILicensingModule public immutable LICENSING_MODULE;
    CoreMetadataModule public immutable CORE_METADATA_MODULE;
    address public immutable _signerAddress;

    uint256 public constant MAX_SUPPLY = 2222;
    uint256 public constant WHITELIST_MAX_P_WALLET = 2;
    uint256 public constant PUBLIC_MAX_P_WALLET = 2;
    uint256 private _totalSupply = 0;

    bool public whitelistMintEnabled = false;
    bool public publicMintEnabled = false;

    mapping(address => uint8) public mintedCount;
    mapping(address => bool) public whitelist;
    mapping(uint256 => address) public tokenIpIds;
    string private _baseUri;

    event Minted(address indexed _from, uint _tokenId, uint _timestamp, address ipId, string tokenUri);
    event PublicMintStatusChanged(bool _enabled, uint _timestamp);
    event WhitelistMintStatusChanged(bool _enabled, uint _timestamp);
    event IPAssetRegistered(uint256 indexed _tokenId, address indexed ipId);
    event WhitelistUpdated(address indexed _address, bool _status, uint _timestamp);

    constructor(
        address ipAssetRegistryAddress,
        address signerAddress,
        address licensingModule,
        address coreMetadataModule,
        string memory baseUri
    )
        ERC721("PiPi", "PIPI")
        Ownable(msg.sender)
    {
        require(ipAssetRegistryAddress != address(0), "Invalid IP Asset Registry address");
        require(signerAddress != address(0), "Invalid signer address");
        require(licensingModule != address(0), "Invalid LicensingModule address");
        require(bytes(baseUri).length > 0, "Invalid base URI");

        IP_ASSET_REGISTRY = IPAssetRegistry(ipAssetRegistryAddress);
        LICENSING_MODULE = ILicensingModule(licensingModule);
        CORE_METADATA_MODULE = CoreMetadataModule(coreMetadataModule);
        _signerAddress = signerAddress;
        _baseUri = baseUri;
    }

    function _baseURI() internal view override returns (string memory) {
        return _baseUri;
    }

    function setBaseURI(string memory newBaseURI) external onlyOwner {
        _baseUri = newBaseURI;
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        return string(abi.encodePacked(_baseUri, StringUtils.uint2str(tokenId), ".json"));
    }

    function setWhitelistMintEnabled(bool _state) external onlyOwner {
        whitelistMintEnabled = _state;
        emit WhitelistMintStatusChanged(_state, block.timestamp);
    }

    function setPublicMintEnabled(bool _state) external onlyOwner {
        publicMintEnabled = _state;
        emit PublicMintStatusChanged(_state, block.timestamp);
    }

    function viewTotalSupply() external view returns (uint256) {
        return _totalSupply;
    }

    function whitelistMint() external payable returns (string memory, address) {
        require(whitelistMintEnabled, "Whitelist mint is not active");
        require(whitelist[msg.sender], "Address not whitelisted");
        require(mintedCount[msg.sender] < WHITELIST_MAX_P_WALLET, "Whitelist mint limit reached");
        require(_totalSupply < MAX_SUPPLY, "Max supply reached");

        return _mintNFT(msg.sender);
    }

    function publicMint(bytes memory signature) external payable returns (string memory, address) {
        require(publicMintEnabled, "Public mint is not active");
        require(mintedCount[msg.sender] < PUBLIC_MAX_P_WALLET, "Public mint limit reached");
        require(_totalSupply < MAX_SUPPLY, "Max supply reached");

        require(_verifySignature(msg.sender, signature), "Invalid signature");

        return _mintNFT(msg.sender);
    }

    function _verifySignature(address sender, bytes memory signature) internal view returns (bool) {
        bytes32 messageHash = keccak256(abi.encodePacked(sender));
        bytes32 ethSignedMessageHash = MessageHashUtils.toEthSignedMessageHash(messageHash);
        address recoveredSigner = ECDSA.recover(ethSignedMessageHash, signature);

        return recoveredSigner == _signerAddress;
    }

    function _mintNFT(address recipient) internal returns (string memory, address) {
        uint256 newTokenId = _totalSupply + 1;

        require(newTokenId <= MAX_SUPPLY, "Max supply reached");

        _totalSupply = newTokenId;
        mintedCount[recipient]++;
        _safeMint(recipient, newTokenId);

        address ipId = _registerAsIPAsset(newTokenId);
        string memory nftUri = tokenURI(newTokenId);
        tokenIpIds[newTokenId] = ipId;

        bytes32 metadataHash = keccak256(abi.encodePacked(nftUri));
        CORE_METADATA_MODULE.setAll(ipId, nftUri, metadataHash, metadataHash);

        registerDerivativeForToken(ipId);

        _safeTransfer(address(this), recipient, newTokenId, "");
        

        emit Minted(recipient, newTokenId, block.timestamp, ipId, nftUri);
        emit IPAssetRegistered(newTokenId, ipId);

        return (nftUri, ipId);
    }

    function _registerAsIPAsset(uint256 tokenId) internal returns (address) {
        try IP_ASSET_REGISTRY.register(block.chainid, address(this), tokenId) returns (address ipId) {
            require(ipId != address(0), "IP Asset registration failed");
            return ipId;
        } catch Error(string memory reason) {
            revert(reason);
        } catch {
            revert("IP Asset registration failed");
        }
    }

    function registerDerivativeForToken(address ipId) internal {
        address[] memory parentIpIds = new address[](1);
        parentIpIds[0] = 0xB1D831271A68Db5c18c8F0B69327446f7C8D0A42;

        uint256[] memory licenseTermsIds = new uint256[](1);
        licenseTermsIds[0] = 1;

        address licenseTemplate = 0x2E896b0b2Fdb7457499B56AAaA4AE55BCB4Cd316;
        bytes memory royaltyContext = hex"0000000000000000000000000000000000000000";
        uint256 maxMintingFee = 0;
        uint32 maxRts = 0;
        uint32 maxRevenueShare = 0;

        LICENSING_MODULE.registerDerivative(
            ipId,
            parentIpIds,
            licenseTermsIds,
            licenseTemplate,
            royaltyContext,
            maxMintingFee,
            maxRts,
            maxRevenueShare
        );
    }

    function addToWhitelist(address _address) external onlyOwner {
        whitelist[_address] = true;

        emit WhitelistUpdated(_address, true, block.timestamp);
    }

    function addToWhitelistMultitude(address[] calldata _addresses) external onlyOwner {
        for (uint32 i = 0; i < _addresses.length; i++) {
            whitelist[_addresses[i]] = true;

            emit WhitelistUpdated(_addresses[i], true, block.timestamp);
        }
    }

    function isWhitelisted(address _address) external view returns (bool) {
        return whitelist[_address];
    }

    function onERC721Received(address, address, uint256, bytes calldata) external pure override returns (bytes4) {
        return IERC721Receiver.onERC721Received.selector;
    }

    function getNftData(uint256 tokenId) external view returns (string memory nftUri, address ipId) {
        return (tokenURI(tokenId), tokenIpIds[tokenId]);
    }
}

[EngrPips]

This Github discussion is primarily for helping people who run into issues while taking the Cyfrin Foundry-Full-Course but if you say what error you are specifically running into maybe we can help you.