Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;
import {FixedPointMathLib} from "solady/src/utils/FixedPointMathLib.sol";
import {SafeTransferLib} from "solady/src/utils/SafeTransferLib.sol";
import {DynamicArrayLib} from "solady/src/utils/DynamicArrayLib.sol";
import {SafeCastLib} from "solady/src/utils/SafeCastLib.sol";
import {LibString} from "solady/src/utils/LibString.sol";
import {ECDSA} from "solady/src/utils/ECDSA.sol";
// Interfaces
import "../Types.sol";
import {IHook} from "../interfaces/IHook.sol";
import {FeeModule} from "../modules/FeeModule.sol";
import {IRewardProxy} from "../interfaces/IRewardProxy.sol";
import {VerifierModule} from "../modules/VerifierModule.sol";
import {VaultInfoResolver} from "../modules/resolvers/VaultInfoResolver.sol";
import {Factory} from "../Factory.sol";
import {YieldToken} from "./YieldToken.sol";
// Libraries
import {LibRewardProxy} from "../utils/LibRewardProxy.sol";
import {ModuleAccessor} from "../utils/ModuleAccessor.sol";
import {TokenNameLib} from "../utils/TokenNameLib.sol";
import {CustomRevert} from "../utils/CustomRevert.sol";
import {LibExpiry} from "../utils/LibExpiry.sol";
import {Events} from "../Events.sol";
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Arithmetic library with operations for fixed-point numbers.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/FixedPointMathLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/FixedPointMathLib.sol)
library FixedPointMathLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev The operation failed, as the output exceeds the maximum value of uint256.
    error ExpOverflow();
    /// @dev The operation failed, as the output exceeds the maximum value of uint256.
    error FactorialOverflow();
    /// @dev The operation failed, due to an overflow.
    error RPowOverflow();
    /// @dev The mantissa is too big to fit.
    error MantissaOverflow();
    /// @dev The operation failed, due to an multiplication overflow.
    error MulWadFailed();
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeTransferLib.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
/// @author Permit2 operations from (https://github.com/Uniswap/permit2/blob/main/src/libraries/Permit2Lib.sol)
///
/// @dev Note:
/// - For ETH transfers, please use `forceSafeTransferETH` for DoS protection.
library SafeTransferLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev The ETH transfer has failed.
    error ETHTransferFailed();
    /// @dev The ERC20 `transferFrom` has failed.
    error TransferFromFailed();
    /// @dev The ERC20 `transfer` has failed.
    error TransferFailed();
    /// @dev The ERC20 `approve` has failed.
    error ApproveFailed();
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Library for memory arrays with automatic capacity resizing.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/DynamicArrayLib.sol)
library DynamicArrayLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev Type to represent a dynamic array in memory.
    /// You can directly assign to `data`, and the `p` function will
    /// take care of the memory allocation.
    struct DynamicArray {
        uint256[] data;
    }
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev The constant returned when the element is not found in the array.
    uint256 internal constant NOT_FOUND = type(uint256).max;
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  UINT256 ARRAY OPERATIONS                  */
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Safe integer casting library that reverts on overflow.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/SafeCastLib.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/math/SafeCast.sol)
/// @dev Optimized for runtime gas for very high number of optimizer runs (i.e. >= 1000000).
library SafeCastLib {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev Unable to cast to the target type due to overflow.
    error Overflow();
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*          UNSIGNED INTEGER SAFE CASTING OPERATIONS          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev Casts `x` to a uint8. Reverts on overflow.
    function toUint8(uint256 x) internal pure returns (uint8) {
        if (x >= 1 << 8) _revertOverflow();
        return uint8(x);
    }
    /// @dev Casts `x` to a uint16. Reverts on overflow.
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
import {LibBytes} from "./LibBytes.sol";
/// @notice Library for converting numbers into strings and other string operations.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibString.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/LibString.sol)
///
/// @dev Note:
/// For performance and bytecode compactness, most of the string operations are restricted to
/// byte strings (7-bit ASCII), except where otherwise specified.
/// Usage of byte string operations on charsets with runes spanning two or more bytes
/// can lead to undefined behavior.
library LibString {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev Goated string storage struct that totally MOGs, no cap, fr.
    /// Uses less gas and bytecode than Solidity's native string storage. It's meta af.
    /// Packs length with the first 31 bytes if <255 bytes, so it’s mad tight.
    struct StringStorage {
        bytes32 _spacer;
    }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Gas optimized ECDSA wrapper.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/ECDSA.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/ECDSA.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/utils/cryptography/ECDSA.sol)
///
/// @dev Note:
/// - The recovery functions use the ecrecover precompile (0x1).
/// - As of Solady version 0.0.68, the `recover` variants will revert upon recovery failure.
///   This is for more safety by default.
///   Use the `tryRecover` variants if you need to get the zero address back
///   upon recovery failure instead.
/// - As of Solady version 0.0.134, all `bytes signature` variants accept both
///   regular 65-byte `(r, s, v)` and EIP-2098 `(r, vs)` short form signatures.
///   See: https://eips.ethereum.org/EIPS/eip-2098
///   This is for calldata efficiency on smart accounts prevalent on L2s.
///
/// WARNING! Do NOT directly use signatures as unique identifiers:
/// - The recovery operations do NOT check if a signature is non-malleable.
/// - Use a nonce in the digest to prevent replay attacks on the same contract.
/// - Use EIP-712 for the digest to prevent replay attacks across different chains and contracts.
///   EIP-712 also enables readable signing of typed data for better user safety.
/// - If you need a unique hash from a signature, please use the `canonicalHash` functions.
library ECDSA {
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;
import "./types/Token.sol" as TokenType;
import "./types/FeePcts.sol" as FeePctsType;
import "./types/ApproxValue.sol" as ApproxValueType;
import "./types/TwoCrypto.sol" as TwoCryptoType;
import "./types/ModuleIndex.sol" as ModuleIndexType;
/// The `FeePcts` type is 256 bits long, and packs the following:
///
/// ```
///   | [uint176]: reserved for future use
///   |                                           | [uint16]: postSettlementFeePct
///   |                                           ↓   | [uint16]: redemptionFeePct
///   |                                           ↓   ↓   | [uint16]: performanceFeePct
///   |                                           ↓   ↓   ↓   | [uint16]: issuanceFeePct
///   |                                           ↓   ↓   ↓   ↓   ↓ [uint16]: splitPctBps
/// 0x00000000000000000000000000000000000000000000AAAABBBBCCCCDDDDEEEE
/// ```
type FeePcts is uint256;
using {FeePctsType.unwrap} for FeePcts global;
/// The `ApproxValue` type represents an approximate value from off-chain sources or `Quoter` contract.
type ApproxValue is uint256;
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
interface ISupplyHook {
    function onSupply(uint256 shares, uint256 principal, bytes calldata data) external;
}
interface IUniteHook {
    function onUnite(uint256 shares, uint256 principal, bytes calldata data) external;
}
interface IHook is ISupplyHook, IUniteHook {}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
import {SafeCastLib} from "solady/src/utils/SafeCastLib.sol";
import {LibClone} from "solady/src/utils/LibClone.sol";
import {FeeParameters, FeePcts} from "../Types.sol";
import {FeePctsLib} from "../utils/FeePctsLib.sol";
import {Errors} from "../Errors.sol";
import {Factory} from "../Factory.sol";
import {BaseModule} from "./BaseModule.sol";
/// @notice FeeModule is responsible for managing fee settings
abstract contract FeeModule is BaseModule {
    function getFeePcts() external view virtual returns (FeePcts);
}
/// @notice ConstantFeeModule is an implementation of FeeModule where all fees except split ratio are set once at initialization
contract ConstantFeeModule is FeeModule {
    using SafeCastLib for uint256;
    bytes32 public constant override VERSION = "2.0.0";
    uint256 private constant MAX_FEE_BPS = 10_000;
    uint256 private constant MAX_SPLIT_RATIO_BPS = 9_500;
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
import {TokenReward} from "src/Types.sol";
interface IRewardProxy {
    function rewardTokens() external view returns (address[] memory);
    function collectReward(address rewardProxy) external returns (TokenReward[] memory);
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
import {LibClone} from "solady/src/utils/LibClone.sol";
import {SafeTransferLib} from "solady/src/utils/SafeTransferLib.sol";
import {FixedPointMathLib} from "solady/src/utils/FixedPointMathLib.sol";
import {VerificationStatus} from "../Types.sol";
import {BaseModule} from "./BaseModule.sol";
import {PrincipalToken} from "src/tokens/PrincipalToken.sol";
/// @notice VerifierModule is used to restrict access to certain functions based on account and deposit cap.
/// @dev Integrators can extend this module to implement custom verification logic.
abstract contract VerifierModule is BaseModule {
    bytes4 constant SUPPLY_SELECTOR = 0x674032b8;
    bytes4 constant SUPPLY_WITH_CALLBACK_SELECTOR = 0x5f04dfe2;
    bytes4 constant ISSUE_SELECTOR = 0xb696a6ad;
    bytes4 constant ISSUE_WITH_CALLBACK_SELECTOR = 0x6d4b055c;
    /// @dev MUST NOT revert.
    /// @dev Key points: to distinguish between verification failure and unexpected error, the function
    /// must return verification status to indicate whether the transaction is allowed or not.
    /// @dev The function MUST return VerificationStatus.Success if the transaction is allowed.
    function verify(bytes4 sig, address caller, uint256 shares, uint256 principal, address receiver)
        external
        view
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;
/// @title VaultInfoResolver
/// @notice Abstract contract for resolving vault information.
abstract contract VaultInfoResolver {
    function asset() public view virtual returns (address);
    function target() public view virtual returns (address);
    function scale() public view virtual returns (uint256);
    function assetDecimals() public view virtual returns (uint8);
    function decimals() public view virtual returns (uint8);
    function label() public pure virtual returns (bytes32);
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;
import {SSTORE2} from "solady/src/utils/SSTORE2.sol";
import {LibClone} from "solady/src/utils/LibClone.sol";
import {LibTransient} from "solady/src/utils/LibTransient.sol";
import {UUPSUpgradeable} from "solady/src/utils/UUPSUpgradeable.sol";
import {EfficientHashLib} from "solady/src/utils/EfficientHashLib.sol";
// Interfaces
import "./Types.sol";
import {IPoolDeployer} from "./interfaces/IPoolDeployer.sol";
// Modules
import {BaseModule} from "./modules/BaseModule.sol";
import {PrincipalToken} from "./tokens/PrincipalToken.sol";
import {AccessManager, AccessManaged} from "./modules/AccessManager.sol";
import {VaultInfoResolver} from "./modules/resolvers/VaultInfoResolver.sol";
// Libraries
import {LibBlueprint} from "./utils/LibBlueprint.sol";
import {ModuleAccessor} from "./utils/ModuleAccessor.sol";
import {Errors} from "./Errors.sol";
import {Events} from "./Events.sol";
import "src/Constants.sol" as Constants;
/// @notice Deployment Suite
///  - Factory is responsible for deploying PrincipalToken, YT and Pool instances.
///  - Factory is agnostic to type of AMM by supporting multiple pool deployers implementations.
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;
import {ERC20} from "solady/src/tokens/ERC20.sol";
import {PrincipalToken} from "./PrincipalToken.sol";
import {TokenNameLib} from "../utils/TokenNameLib.sol";
import {Errors} from "../Errors.sol";
contract YieldToken is ERC20 {
    PrincipalToken public immutable i_principalToken;
    constructor(address _pt) {
        i_principalToken = PrincipalToken(_pt);
    }
    function name() public view override returns (string memory) {
        address underlying = _underlying();
        uint256 expiry = _maturity();
        return TokenNameLib.yieldTokenName(underlying, expiry);
    }
    function symbol() public view override returns (string memory) {
        address underlying = _underlying();
        uint256 expiry = _maturity();
        return TokenNameLib.yieldTokenSymbol(underlying, expiry);
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
// https://gist.github.com/Vectorized/ebb23b2b5395b6d6aa83fc36af98a18c
import {TokenReward} from "../Types.sol";
library LibRewardProxy {
    function delegateCallCollectReward(address rewardProxy) internal returns (TokenReward[] memory rewards) {
        assembly {
            mstore(0x14, rewardProxy) // Store the argument.
            mstore(0x00, 0x82c97b8d000000000000000000000000) // `collectReward(address)`.
            if iszero(delegatecall(gas(), rewardProxy, 0x10, 0x24, codesize(), 0x00)) {
                mstore(0x00, 0x3f12e961) // `PrincipalToken_CollectRewardFailed()`
                revert(0x1c, 0x04)
            }
            let m := mload(0x40) // Grab the free memory pointer.
            returndatacopy(m, 0x00, returndatasize()) // Just copy all of the return data.
            let t := add(m, mload(m)) // Pointer to `rewards` in the returndata.
            let n := mload(t) // `rewards.length`.
            let r := add(t, 0x20) // Pointer to `rewards[0]` in the returndata.
            // Skip the copied data.
            // We will initialize rewards as an array of pointers into the copied data.
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
import {SSTORE2} from "solady/src/utils/SSTORE2.sol";
import {ModuleIndex} from "../Types.sol";
library ModuleAccessor {
    error ModuleOutOfBounds();
    function read(address pointer) internal view returns (address[] memory m) {
        // The first 32 bytes of the data is the offset to the start of the contents of the `data`. 0x20 is expected here.
        // The contents of the `data` is an address[] array.
        bytes memory data = SSTORE2.read(pointer);
        assembly {
            m := add(data, 0x40) // Grab the encoded array
        }
    }
    /// @notice Get a module address by index.
    /// @dev Note: The module index is zero-based. Reverts with ModuleOutOfBounds if index is out of range.
    function get(address[] memory m, ModuleIndex idx) internal pure returns (address module) {
        assembly {
            if iszero(lt(idx, mload(m))) {
                mstore(0x00, 0x13bec8a3) // `ModuleOutOfBounds()`.
                revert(0x1c, 0x04)
            }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
import {MetadataReaderLib} from "solady/src/utils/MetadataReaderLib.sol";
import {DateTimeLib} from "solady/src/utils/DateTimeLib.sol";
import {LibString} from "solady/src/utils/LibString.sol";
/// @dev Inputs `expiry` that exceed maximum timestamp results in undefined behavior.
library TokenNameLib {
    using LibString for uint256;
    string constant PY_NAME_PREFIX = "NapierV2-";
    function principalTokenName(address target, uint256 expiry) internal view returns (string memory) {
        string memory underlyingName = MetadataReaderLib.readName(target);
        return string.concat(PY_NAME_PREFIX, "PT-", underlyingName, "@", expiryToDate(expiry));
    }
    function principalTokenSymbol(address target, uint256 expiry) internal view returns (string memory) {
        string memory underlyingSymbol = MetadataReaderLib.readSymbol(target);
        return string.concat("PT-", underlyingSymbol, "@", expiryToDate(expiry));
    }
    function yieldTokenName(address target, uint256 expiry) internal view returns (string memory) {
        string memory underlyingName = MetadataReaderLib.readName(target);
        return string.concat(PY_NAME_PREFIX, "YT-", underlyingName, "@", expiryToDate(expiry));
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
/// @notice Forked from https://github.com/Uniswap/v4-core/blob/c8173143cf1e6f1c6c7b682a3563b263f149255f/src/libraries/CustomRevert.sol
/// @title Library for reverting with custom errors efficiently
/// @notice Contains functions for reverting with custom errors with different argument types efficiently
/// @dev To use this library, declare `using CustomRevert for bytes4;` and replace `revert CustomError()` with
/// `CustomError.selector.revertWith()`
/// @dev The functions may tamper with the free memory pointer but it is fine since the call context is exited immediately
library CustomRevert {
    /// @dev Reverts with the selector of a custom error in the scratch space
    function revertWith(bytes4 selector) internal pure {
        assembly ("memory-safe") {
            mstore(0, selector)
            revert(0, 0x04)
        }
    }
    function revertWith(bytes4 selector, uint256 value) internal pure {
        assembly ("memory-safe") {
            mstore(0, selector)
            mstore(0x04, value)
            revert(0, 0x24)
        }
    }
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
import {EIP5095} from "../interfaces/EIP5095.sol";
library LibExpiry {
    function isExpired(uint256 expiry) internal view returns (bool) {
        return block.timestamp >= expiry;
    }
    function isExpired(EIP5095 pt) internal view returns (bool) {
        return block.timestamp >= pt.maturity();
    }
    function isNotExpired(EIP5095 pt) internal view returns (bool) {
        return block.timestamp < pt.maturity();
    }
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
import "./Types.sol";
library Events {
    /// @dev `keccak256(bytes("YieldFeeAccrued(uint256)"))`.
    uint256 constant _YIELD_FEE_ACCRUED_EVENT_SIGNATURE =
        0xac693c1b946bcf3ad16baa51b744b990b94ea9c79ac71f2d1b5369a823a7d065;
    /// @dev `keccak256(bytes("YieldAccrued(address,uint256,uint256)"))`.
    uint256 constant _YIELD_ACCRUED_EVENT_SIGNATURE = 0xaced61c86c507aa3c2be43553434c6ff191ea7cbbd812491a6ae59abc99d29dc;
    /// @dev `keccak256(bytes("Supply(address,address,uint256,uint256)"))`.
    uint256 constant _SUPPLY_EVENT_SIGNATURE = 0x69a3ea8e6d6819646fbf2b98e9e8dd6d9cd343852550621038b4d72e4aa6dd37;
    /// @dev `keccak256(bytes("Unite(address,address,uint256,uint256)"))`.
    uint256 constant _UNITE_EVENT_SIGNATURE = 0xc78456d21b5d71405d0daba05157c90a4a412d7379fd21c3bc8a679b65b13b5f;
    /// @dev `keccak256(bytes("Redeem(address,address,address,uint256,uint256)"))`.
    uint256 constant _REDEEM_EVENT_SIGNATURE = 0xaee47cdf925cf525fdae94f9777ee5a06cac37e1c41220d0a8a89ed154f62d1c;
    /// @dev `keccak256(bytes("InterestCollected(address,address,address,uint256)"))`.
    uint256 constant _INTEREST_COLLECTED_EVENT_SIGNATURE =
        0x54affe52c3988f9c9e1d9d4673ffb7b398832c049d65e63b51326c89255e8529;
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
library Errors {
    error AccessManaged_Restricted();
    error Expired();
    error NotExpired();
    error PrincipalToken_NotFactory();
    error PrincipalToken_VerificationFailed(uint256 code);
    error PrincipalToken_CollectRewardFailed();
    error PrincipalToken_NotApprovedCollector();
    error PrincipalToken_OnlyYieldToken();
    error PrincipalToken_InsufficientSharesReceived();
    error PrincipalToken_UnderlyingTokenBalanceChanged();
    error PrincipalToken_Unstoppable();
    error PrincipalToken_ProtectedToken();
    error YieldToken_OnlyPrincipalToken();
    // Module
    error Module_CallFailed();
    // FeeModule
    error FeeModule_InvalidFeeParam();
    error FeeModule_SplitFeeExceedsMaximum();
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
uint256 constant BASIS_POINTS = 10_000;
uint256 constant WAD = 1e18;
address constant NATIVE_ETH = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
// Roles
uint256 constant FEE_MANAGER_ROLE = 1 << 0;
uint256 constant FEE_COLLECTOR_ROLE = 1 << 1;
uint256 constant DEV_ROLE = 1 << 2;
uint256 constant PAUSER_ROLE = 1 << 3;
uint256 constant GOVERNANCE_ROLE = 1 << 4;
uint256 constant CONNECTOR_REGISTRY_ROLE = 1 << 5;
// TwoCrypto
uint256 constant TARGET_INDEX = 0;
uint256 constant PT_INDEX = 1;
// Currency
address constant WETH_ETHEREUM_MAINNET = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
// Default fee split ratio (100% to Curator)
uint16 constant DEFAULT_SPLIT_RATIO_BPS = uint16(BASIS_POINTS);
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
import {FeePcts} from "../Types.sol";
library FeePctsLib {
    uint256 private constant FEE_MASK = 0xFFFF; // 16 bits mask
    uint256 private constant SPLIT_RATIO_OFFSET = 0;
    function getSplitPctBps(FeePcts self) internal pure returns (uint16) {
        return uint16(FeePcts.unwrap(self));
    }
    function getIssuanceFeePctBps(FeePcts self) internal pure returns (uint16) {
        return uint16(FeePcts.unwrap(self) >> 16);
    }
    function getPerformanceFeePctBps(FeePcts self) internal pure returns (uint16) {
        return uint16(FeePcts.unwrap(self) >> 32);
    }
    function getRedemptionFeePctBps(FeePcts self) internal pure returns (uint16) {
        return uint16(FeePcts.unwrap(self) >> 48);
    }
    function getPostSettlementFeePctBps(FeePcts self) internal pure returns (uint16) {
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;
import {FixedPointMathLib} from "solady/src/utils/FixedPointMathLib.sol";
import {SafeCastLib} from "solady/src/utils/SafeCastLib.sol";
type YieldIndex is uint128;
/// @param maxscale The last collected YBT share price in the underlying token.
/// @param globalIndex The accumulator of the accrued yield per YT.
struct Snapshot {
    uint128 maxscale;
    YieldIndex globalIndex;
}
struct Yield {
    YieldIndex userIndex;
    uint128 accrued;
}
using {unwrap} for YieldIndex global;
using {eq as ==, add as +, sub as -} for YieldIndex global;
function unwrap(YieldIndex x) pure returns (uint128 result) {
    result = YieldIndex.unwrap(x);
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;
import {FixedPointMathLib} from "solady/src/utils/FixedPointMathLib.sol";
import {SafeCastLib} from "solady/src/utils/SafeCastLib.sol";
type RewardIndex is uint128;
/// @notice A struct to store the reward information for a user.
/// @param userIndex The reward index when the user last accrued reward.
/// @param accrued The accrued reward since the last time the user accrued reward.
struct Reward {
    RewardIndex userIndex; // rewardIndex_u(t_1): the reward index when the user last accrued reward
    uint128 accrued; // r_u(t_1): the accrued reward since the last time the user accrued reward
}
using {unwrap} for RewardIndex global;
using {eq as ==, add as +, sub as -} for RewardIndex global;
function unwrap(RewardIndex x) pure returns (uint128 result) {
    result = RewardIndex.unwrap(x);
}
function wrap(uint128 x) pure returns (RewardIndex result) {
    result = RewardIndex.wrap(x);
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.0;
/// @notice Principal tokens (zero-coupon tokens) are redeemable for a single underlying EIP-20 token at a future timestamp.
/// https://eips.ethereum.org/EIPS/eip-5095
interface EIP5095 {
    /// @dev We think EIP-5095 `Redeem` event lacks `by` and `principal` fields.
    /// So we emit our own `Redeem` event instead of EIP-5095 `Redeem` event.
    event Redeem(address indexed owner, address indexed receiver, uint256 underlyings);
    /// @notice The address of the underlying token used by the Principal Token for accounting, and redeeming.
    function underlying() external view returns (address);
    /// @notice The unix timestamp (uint256) at or after which Principal Tokens can be redeemed for their underlying deposit.
    function maturity() external view returns (uint256 timestamp);
    /// @notice The amount of underlying that would be exchanged for the amount of PTs provided, in an ideal scenario where all the conditions are met
        .
    /// @notice Before maturity, the amount of underlying returned is as if the PTs would be at maturity.
    /// @notice MUST NOT be inclusive of any fees that are charged against redemptions.
    /// @notice MUST NOT show any variations depending on the caller.
    /// @notice MUST NOT reflect slippage or other on-chain conditions, when performing the actual redemption.
    /// @notice MUST NOT revert unless due to integer overflow caused by an unreasonably large input.
    /// @notice MUST round down towards 0.
    /// @notice This calculation MAY NOT reflect the “per-user” price-per-principal-token, and instead should reflect the “average-user’s” price-per
        -principal-token, meaning what the average user should expect to see when exchanging to and from.
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/Pausable.sol)
pragma solidity ^0.8.20;
import {Context} from "../utils/Context.sol";
/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract Pausable is Context {
    bool private _paused;
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);
    /**
     * @dev Emitted when the pause is lifted by `account`.
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Reentrancy guard mixin.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/ReentrancyGuard.sol)
abstract contract ReentrancyGuard {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev Unauthorized reentrant call.
    error Reentrancy();
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STORAGE                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev Equivalent to: `uint72(bytes9(keccak256("_REENTRANCY_GUARD_SLOT")))`.
    /// 9 bytes is large enough to avoid collisions with lower slots,
    /// but not too large to result in excessive bytecode bloat.
    uint256 private constant _REENTRANCY_GUARD_SLOT = 0x929eee149b4bd21268;
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                      REENTRANCY GUARD                      */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Simple ERC20 + EIP-2612 implementation.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/tokens/ERC20.sol)
/// @author Modified from Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
/// @author Modified from OpenZeppelin (https://github.com/OpenZeppelin/openzeppelin-contracts/blob/master/contracts/token/ERC20/ERC20.sol)
///
/// @dev Note:
/// - The ERC20 standard allows minting and transferring to and from the zero address,
///   minting and transferring zero tokens, as well as self-approvals.
///   For performance, this implementation WILL NOT revert for such actions.
///   Please add any checks with overrides if desired.
/// - The `permit` function uses the ecrecover precompile (0x1).
///
/// If you are overriding:
/// - NEVER violate the ERC20 invariant:
///   the total sum of all balances must be equal to `totalSupply()`.
/// - Check that the overridden function is actually used in the function you want to
///   change the behavior of. Much of the code has been manually inlined for performance.
abstract contract ERC20 {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                       CUSTOM ERRORS                        */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev The total supply has overflowed.
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.10;
import {OwnableRoles} from "solady/src/auth/OwnableRoles.sol";
import {Initializable} from "solady/src/utils/Initializable.sol";
import {Multicallable} from "solady/src/utils/Multicallable.sol";
import "../Constants.sol" as Constants;
import {Errors} from "../Errors.sol";
/// @notice Access Manager module for managing single owner and multiple roles for multiple contracts and functions.
/// @dev Each PrincipalToken instance will have its own AccessManager instance to manage access control.
/// @dev AccessManager is a minimal proxy implementation to reduce deployment costs.
/// @dev Note: AccessManager must be initialized after deployment to set initial owner.
contract AccessManager is OwnableRoles, Initializable, Multicallable {
    /// @notice Mapping of target contracts to their function selectors and roles that are allowed to call the function
    mapping(address target => mapping(bytes4 selector => uint256 roles)) private s_targets;
    /// @notice Emitted when roles are granted for a target function
    /// @param target The address of the target contract
    /// @param selector The function selector
    /// @param roles The roles being granted
    event TargetFunctionRolesGranted(address indexed target, bytes4 indexed selector, uint256 indexed roles);
    /// @notice Emitted when roles are revoked for a target function
    /// @param target The address of the target contract
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;
import {SafeTransferLib} from "solady/src/utils/SafeTransferLib.sol";
abstract contract LibApproval {
    /// @dev The approval slot of (`src`, `spender`) is given by:
    /// ```
    ///     mstore(0x20, spender)
    ///     mstore(0x0c, _IS_APPROVED_SLOT_SEED)
    ///     mstore(0x00, src)
    ///     let allowanceSlot := keccak256(0x0c, 0x34)
    /// ```
    /// @dev Optimized storage slot for approval flags
    /// `mapping (address src => mapping (address spender => uint256 approved)) isApproved;`
    uint256 constant _IS_APPROVED_SLOT_SEED = 0xa8fe4407;
    /// @dev Get the approval status of the `spender` for the `src`. Return true if approved, 0 otherwise.
    function isApproved(address src, address spender) internal view returns (bool approved) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x20, spender)
            mstore(0x0c, _IS_APPROVED_SLOT_SEED)
            mstore(0x00, src)
            approved := sload(keccak256(0x0c, 0x34))
        }
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: MIT
pragma solidity ^0.8.4;
/// @notice Library for byte related operations.
/// @author Solady (https://github.com/vectorized/solady/blob/main/src/utils/LibBytes.sol)
library LibBytes {
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                          STRUCTS                           */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev Goated bytes storage struct that totally MOGs, no cap, fr.
    /// Uses less gas and bytecode than Solidity's native bytes storage. It's meta af.
    /// Packs length with the first 31 bytes if <255 bytes, so it’s mad tight.
    struct BytesStorage {
        bytes32 _spacer;
    }
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                         CONSTANTS                          */
    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
    /// @dev The constant returned when the `search` is not found in the bytes.
    uint256 internal constant NOT_FOUND = type(uint256).max;
    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
    /*                  BYTE STORAGE OPERATIONS                   */
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;
import {ERC20} from "solady/src/tokens/ERC20.sol";
import {Token} from "../Types.sol";
import {NATIVE_ETH} from "../Constants.sol";
function unwrap(Token x) pure returns (address result) {
    result = Token.unwrap(x);
}
function erc20(Token token) pure returns (ERC20 result) {
    result = ERC20(Token.unwrap(token));
}
function isNative(Token x) pure returns (bool result) {
    result = Token.unwrap(x) == NATIVE_ETH;
}
function isNotNative(Token x) pure returns (bool result) {
    result = Token.unwrap(x) != NATIVE_ETH;
}
function eq(Token token0, address token1) pure returns (bool result) {
    result = Token.unwrap(token0) == token1;
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;
import {FeePcts} from "../Types.sol";
function unwrap(FeePcts x) pure returns (uint256 result) {
    result = FeePcts.unwrap(x);
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;
import {ApproxValue} from "../Types.sol";
function unwrap(ApproxValue x) pure returns (uint256 result) {
    result = ApproxValue.unwrap(x);
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;
import {TwoCrypto} from "../Types.sol";
function unwrap(TwoCrypto x) pure returns (address result) {
    result = TwoCrypto.unwrap(x);
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.8.24;
import {ModuleIndex, MAX_MODULES} from "../Types.sol";
function unwrap(ModuleIndex x) pure returns (uint256 result) {
    result = ModuleIndex.unwrap(x);
}
/// @dev Checks if the given module index is supported by Factory.
/// @dev Even if Factory supports the module, Principal Token instance may not support it due to the length of the array mismatch.
function isSupportedByFactory(ModuleIndex x) pure returns (bool result) {
    result = ModuleIndex.unwrap(x) < MAX_MODULES;
}
function eq(ModuleIndex x, ModuleIndex y) pure returns (bool result) {
    result = ModuleIndex.unwrap(x) == ModuleIndex.unwrap(y);
}
XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX