SPL Discriminator

This library allows for easy management of 8-byte discriminators.

The ArrayDiscriminator Struct

With this crate, you can leverage the ArrayDiscriminator type to manage an 8-byte discriminator for generic purposes.

rust let my_discriminator = ArrayDiscriminator::new([8, 5, 1, 56, 10, 53, 9, 198]);

The new(..) function is also a constant function, so you can use ArrayDiscriminator in constants as well.

rust const MY_DISCRIMINATOR: ArrayDiscriminator = ArrayDiscriminator::new([8, 5, 1, 56, 10, 53, 9, 198]);

The ArrayDiscriminator struct also offers another constant function as_slice(&self), so you can use as_slice() in constants as well.

rust const MY_DISCRIMINATOR_SLICE: &[u8] = MY_DISCRIMINATOR.as_slice();

The SplDiscriminate Trait

A trait, SplDiscriminate is also available, which will give you the ArrayDiscriminator constant type and also a slice representation of the discriminator. This can be particularly handy with match statements.

rust /// A trait for managing 8-byte discriminators in a slab of bytes pub trait SplDiscriminate { /// The 8-byte discriminator as a `[u8; 8]` const SPL_DISCRIMINATOR: ArrayDiscriminator; /// The 8-byte discriminator as a slice (`&[u8]`) const SPL_DISCRIMINATOR_SLICE: &'static [u8] = Self::SPL_DISCRIMINATOR.as_slice(); }

The SplDiscriminate Derive Macro

The SplDiscriminate derive macro is a particularly useful tool for those who wish to derive their 8-byte discriminator from a particular string literal. Typically, you would have to run a hash function against the string literal, then copy the first 8 bytes, and then hard-code those bytes into a statement like the one above.

Instead, you can simply annotate a struct or enum with SplDiscriminate and provide a namespace via the discriminator_namespace attribute, and the macro will automatically derive the 8-byte discriminator for you!

```rust

[derive(SplDiscriminate)] // Implements SplDiscriminate for your struct/enum using your declared string literal namespace

[discriminatornamespace("somediscriminator_namespace")]

pub struct MyInstruction1 { arg1: String, arg2: u8, }

let mydiscriminator: ArrayDiscriminator = MyInstruction1::SPLDISCRIMINATOR; let mydiscriminatorslice: &[u8] = MyInstruction1::SPLDISCRIMINATORSLICE; ```

Note: the 8-byte discriminator derived using the macro is always the first 8 bytes of the resulting hashed bytes.