{
    "Function": "slitherConstructorConstantVariables",
    "File": "src/libraries/DelegateTokenStorageHelpers.sol",
    "Parent Contracts": [],
    "High-Level Calls": [],
    "Internal Calls": [],
    "Library Calls": [],
    "Low-Level Calls": [],
    "Code": "library DelegateTokenStorageHelpers {\n    /// @dev Use this to syntactically store the max of the expiry\n    uint256 internal constant MAX_EXPIRY = type(uint96).max;\n\n    ///////////// ID Flags /////////////\n\n    /// @dev Standardizes registryHash storage flags to prevent double-creation and griefing\n    /// @dev ID_AVAILABLE should be zero since this is the default for a storage slot\n    uint256 internal constant ID_AVAILABLE = 0;\n    uint256 internal constant ID_USED = 1;\n\n    ///////////// Info positions /////////////\n\n    /// @dev Standardizes storage positions of delegateInfo mapping data\n    /// @dev must start at zero and end at 2\n    uint256 internal constant REGISTRY_HASH_POSITION = 0;\n    uint256 internal constant PACKED_INFO_POSITION = 1; // PACKED (address approved, uint96 expiry)\n    uint256 internal constant UNDERLYING_AMOUNT_POSITION = 2; // Not used by 721 delegations\n\n    ///////////// Callback Flags /////////////\n\n    /// @dev all callback flags should be non zero to reduce storage read / write costs\n    /// @dev all callback flags should be unique\n    /// Principal Token callbacks\n    uint256 internal constant MINT_NOT_AUTHORIZED = 1;\n    uint256 internal constant MINT_AUTHORIZED = 2;\n    uint256 internal constant BURN_NOT_AUTHORIZED = 3;\n    uint256 internal constant BURN_AUTHORIZED = 4;\n\n    /// @dev should preserve the expiry in the lower 96 bits in storage, and update the upper 160 bits with approved address\n    function writeApproved(mapping(uint256 delegateTokenId => uint256[3] info) storage delegateTokenInfo, uint256 delegateTokenId, address approved) internal {\n        uint96 expiry = uint96(delegateTokenInfo[delegateTokenId][PACKED_INFO_POSITION]);\n        delegateTokenInfo[delegateTokenId][PACKED_INFO_POSITION] = (uint256(uint160(approved)) << 96) | expiry;\n    }\n\n    /// @dev should preserve approved in the upper 160 bits, and update the lower 96 bits with expiry\n    /// @dev should revert if expiry exceeds 96 bits\n    function writeExpiry(mapping(uint256 delegateTokenId => uint256[3] info) storage delegateTokenInfo, uint256 delegateTokenId, uint256 expiry) internal {\n        if (expiry > MAX_EXPIRY) revert Errors.ExpiryTooLarge();\n        address approved = address(uint160(delegateTokenInfo[delegateTokenId][PACKED_INFO_POSITION] >> 96));\n        delegateTokenInfo[delegateTokenId][PACKED_INFO_POSITION] = (uint256(uint160(approved)) << 96) | expiry;\n    }\n\n    function writeRegistryHash(mapping(uint256 delegateTokenId => uint256[3] info) storage delegateTokenInfo, uint256 delegateTokenId, bytes32 registryHash) internal {\n        delegateTokenInfo[delegateTokenId][REGISTRY_HASH_POSITION] = uint256(registryHash);\n    }\n\n    function writeUnderlyingAmount(mapping(uint256 delegateTokenId => uint256[3] info) storage delegateTokenInfo, uint256 delegateTokenId, uint256 underlyingAmount) internal {\n        delegateTokenInfo[delegateTokenId][UNDERLYING_AMOUNT_POSITION] = underlyingAmount;\n    }\n\n    function incrementBalance(mapping(address delegateTokenHolder => uint256 balance) storage balances, address delegateTokenHolder) internal {\n        unchecked {\n            ++balances[delegateTokenHolder];\n        } // Infeasible that this will overflow\n    }\n\n    function decrementBalance(mapping(address delegateTokenHolder => uint256 balance) storage balances, address delegateTokenHolder) internal {\n        unchecked {\n            --balances[delegateTokenHolder];\n        } // Reasonable to expect this not to underflow\n    }\n\n    /// @notice helper function for burning a principal token\n    /// @dev must revert if burnAuthorized is not set to BURN_NOT_AUTHORIZED flag\n    function burnPrincipal(address principalToken, Structs.Uint256 storage principalBurnAuthorization, uint256 delegateTokenId) internal {\n        if (principalBurnAuthorization.flag == BURN_NOT_AUTHORIZED) {\n            principalBurnAuthorization.flag = BURN_AUTHORIZED;\n            PrincipalToken(principalToken).burn(msg.sender, delegateTokenId);\n            principalBurnAuthorization.flag = BURN_NOT_AUTHORIZED;\n            return;\n        }\n        revert Errors.BurnAuthorized();\n    }\n\n    /// @notice helper function for minting a principal token\n    /// @dev must revert if mintAuthorized has already been set to MINT_AUTHORIZED flag\n    function mintPrincipal(address principalToken, Structs.Uint256 storage principalMintAuthorization, address principalRecipient, uint256 delegateTokenId) internal {\n        if (principalMintAuthorization.flag == MINT_NOT_AUTHORIZED) {\n            principalMintAuthorization.flag = MINT_AUTHORIZED;\n            PrincipalToken(principalToken).mint(principalRecipient, delegateTokenId);\n            principalMintAuthorization.flag = MINT_NOT_AUTHORIZED;\n            return;\n        }\n        revert Errors.MintAuthorized();\n    }\n\n    /// @dev must revert if delegate token did not call burn on the Principal Token for the delegateTokenId\n    /// @dev must revert if principal token is not the caller\n    function checkBurnAuthorized(address principalToken, Structs.Uint256 storage principalBurnAuthorization) internal view {\n        principalIsCaller(principalToken);\n        if (principalBurnAuthorization.flag == BURN_AUTHORIZED) return;\n        revert Errors.BurnNotAuthorized();\n    }\n\n    /// @dev must revert if delegate token did not call burn on the Principal Token for the delegateTokenId\n    /// @dev must revert if principal token is not the caller\n    function checkMintAuthorized(address principalToken, Structs.Uint256 storage principalMintAuthorization) internal view {\n        principalIsCaller(principalToken);\n        if (principalMintAuthorization.flag == MINT_AUTHORIZED) return;\n        revert Errors.MintNotAuthorized();\n    }\n\n    /// @notice helper function to revert if caller is not Principal Token\n    /// @dev must revert if msg.sender is not the principal token\n    function principalIsCaller(address principalToken) internal view {\n        if (msg.sender == principalToken) return;\n        revert Errors.CallerNotPrincipalToken();\n    }\n\n    function revertAlreadyExisted(mapping(uint256 delegateTokenId => uint256[3] info) storage delegateTokenInfo, uint256 delegateTokenId) internal view {\n        if (delegateTokenInfo[delegateTokenId][REGISTRY_HASH_POSITION] == ID_AVAILABLE) return;\n        revert Errors.AlreadyExisted(delegateTokenId);\n    }\n\n    function revertNotOperator(mapping(address account => mapping(address operator => bool enabled)) storage accountOperator, address account) internal view {\n        if (msg.sender == account || accountOperator[account][msg.sender]) return;\n        revert Errors.NotOperator(msg.sender, account);\n    }\n\n    function readApproved(mapping(uint256 delegateTokenId => uint256[3] info) storage delegateTokenInfo, uint256 delegateTokenId) internal view returns (address) {\n        return address(uint160(delegateTokenInfo[delegateTokenId][PACKED_INFO_POSITION] >> 96));\n    }\n\n    function readExpiry(mapping(uint256 delegateTokenId => uint256[3] info) storage delegateTokenInfo, uint256 delegateTokenId) internal view returns (uint256) {\n        return uint96(delegateTokenInfo[delegateTokenId][PACKED_INFO_POSITION]);\n    }\n\n    function readRegistryHash(mapping(uint256 delegateTokenId => uint256[3] info) storage delegateTokenInfo, uint256 delegateTokenId) internal view returns (bytes32) {\n        return bytes32(delegateTokenInfo[delegateTokenId][REGISTRY_HASH_POSITION]);\n    }\n\n    function readUnderlyingAmount(mapping(uint256 delegateTokenId => uint256[3] info) storage delegateTokenInfo, uint256 delegateTokenId) internal view returns (uint256) {\n        return delegateTokenInfo[delegateTokenId][UNDERLYING_AMOUNT_POSITION];\n    }\n\n    function revertNotApprovedOrOperator(\n        mapping(address account => mapping(address operator => bool enabled)) storage accountOperator,\n        mapping(uint256 delegateTokenId => uint256[3] info) storage delegateTokenInfo,\n        address account,\n        uint256 delegateTokenId\n    ) internal view {\n        if (msg.sender == account || accountOperator[account][msg.sender] || msg.sender == readApproved(delegateTokenInfo, delegateTokenId)) return;\n        revert Errors.NotApproved(msg.sender, delegateTokenId);\n    }\n\n    /// @dev should only revert if expiry has not expired AND caller is not the delegateTokenHolder AND not approved for the delegateTokenId AND not an operator for\n    /// delegateTokenHolder\n    function revertInvalidWithdrawalConditions(\n        mapping(uint256 delegateTokenId => uint256[3] info) storage delegateTokenInfo,\n        mapping(address account => mapping(address operator => bool enabled)) storage accountOperator,\n        uint256 delegateTokenId,\n        address delegateTokenHolder\n    ) internal view {\n        //slither-disable-next-line timestamp\n        if (block.timestamp < readExpiry(delegateTokenInfo, delegateTokenId)) {\n            if (delegateTokenHolder == msg.sender || msg.sender == readApproved(delegateTokenInfo, delegateTokenId) || accountOperator[delegateTokenHolder][msg.sender]) {\n                return;\n            }\n            revert Errors.WithdrawNotAvailable(delegateTokenId, readExpiry(delegateTokenInfo, delegateTokenId), block.timestamp);\n        }\n    }\n\n    function revertNotMinted(mapping(uint256 delegateTokenId => uint256[3] info) storage delegateTokenInfo, uint256 delegateTokenId) internal view {\n        uint256 registryHash = delegateTokenInfo[delegateTokenId][REGISTRY_HASH_POSITION];\n        if (registryHash == ID_AVAILABLE || registryHash == ID_USED) {\n            revert Errors.NotMinted(delegateTokenId);\n        }\n    }\n\n    /// @dev does not read from storage, make sure the registryHash of the corresponding delegateTokenId is passed to have the intended effect\n    function revertNotMinted(bytes32 registryHash, uint256 delegateTokenId) internal pure {\n        if (uint256(registryHash) == ID_AVAILABLE || uint256(registryHash) == ID_USED) {\n            revert Errors.NotMinted(delegateTokenId);\n        }\n    }\n}"
}