Presentation context for feature flags.

Per BOLT #9, features are presented in different message contexts:

• Init - the init message
• NodeAnn - node_announcement messages
• ChanAnn - channel_announcement messages (normal)
• ChanAnnOdd - channel_announcement, always odd (optional)
• ChanAnnEven - channel_announcement, always even (required)
• Invoice - BOLT 11 invoices
• Blinded - allowed_features field of a blinded path
• ChanType - channel_type field when opening channels

Check if a context is a channel announcement context (C, C-, or C+).

For channel contexts with forced parity, return Just the required parity: True for even (C+), False for odd (C-). Returns Nothing for contexts without forced parity.

A bit index into a feature vector. Bit 0 is the least significant bit.

Valid range: 0-65535 (sufficient for any practical feature flag).

Smart constructor for BitIndex. Always succeeds since all Word16 values are valid.

Whether a feature is set as required or optional.

Per BOLT #9, each feature has a pair of bits: the even bit indicates required (compulsory) support, the odd bit indicates optional support.

A required (compulsory) feature bit. Required bits are always even.

Smart constructor for RequiredBit. Returns Nothing if the bit index is odd.

>>> requiredBit 16
Just (RequiredBit {unRequiredBit = 16})
>>> requiredBit 17
Nothing

Convert a BitIndex to a RequiredBit. Returns Nothing if odd.

An optional feature bit. Optional bits are always odd.

Smart constructor for OptionalBit. Returns Nothing if the bit index is even.

>>> optionalBit 17
Just (OptionalBit {unOptionalBit = 17})
>>> optionalBit 16
Nothing

Convert a BitIndex to an OptionalBit. Returns Nothing if even.

A feature vector represented as a strict ByteString.

The vector is stored in big-endian byte order (most significant byte first), with bits numbered from the least significant bit of the last byte. Bit 0 is at position 0 of the last byte.

The empty feature vector (no features set).

>>> empty
FeatureVector {unFeatureVector = ""}

Wrap a ByteString as a FeatureVector.

Set a bit in the feature vector.

>>> set (bitIndex 0) empty
FeatureVector {unFeatureVector = "\SOH"}
>>> set (bitIndex 8) empty
FeatureVector {unFeatureVector = "\SOH\NUL"}

Clear a bit in the feature vector.

Test if a bit is set in the feature vector.

>>> member (bitIndex 0) (set (bitIndex 0) empty)
True
>>> member (bitIndex 1) (set (bitIndex 0) empty)
False