Generate Rust enum shells from spec enumerations

This PR teaches the generator to emit Rust `enum` definitions from the spec's `EnumerationSpec` entries, replacing 9 previously hand-written enum shells with generated ones. The spec carries enumerations at the category level (today they all live under `shared`), so discovery is a simple walk over `category.enumerations` — no extra config and no additions to the override surface.

Each generated enum gets the standard derive set (`Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize`) plus `#[serde(rename_all = "camelCase")]`. Variants are `pascalCase(spec name)` in declaration order, with enum-level and variant-level docs propagated from the spec. The generator deliberately does not emit `#[derive(Default)]`: the spec doesn't carry a "default variant" notion, so any required `Default` lives in a hand-written companion file alongside the generated shell — the same generated-type / hand-written-impls split already used for `Number`.

Reconciling the spec with the existing Rust crate required one breaking rename: `Endianness::{Big, Little} → Endianness::{Be, Le}`, since the generator derives variant names directly from the spec's `[be, le]` rather than carrying a per-enum override. The hand-written `TryFrom` impls still accept both the short and long forms as input. `NumberFormat` variant ordering also shifts from semantic to alphabetic (matching spec order); no `match` site relies on the old ordering. `instruction_node.rs`, `instruction_status_node.rs`, `shared/bytes_encoding.rs`, and the `type_nodes/{number,pre_offset,post_offset}_type_node.rs` files each lose their inline enum definition and keep only the bespoke impls (constructors, `TryFrom`, `Default`) the spec can't express; two new files in `shared/` hold the `Default` impls for `InstructionLifecycle` and `OptionalAccountStrategy` so the per-type generated/hand-written symmetry stays clean.

Workspace-wide: 1006 cargo tests pass unchanged, fmt and clippy stay clean, `pnpm test` grew by 6 enumPage tests (113 → 119), and `pnpm generate` round-trips deterministically.

Author: lorisleiva

codama-attributes/src/codama_directives/type_nodes/number_type_node.rs

@@ -6,7 +6,7 @@ impl FromMeta for NumberTypeNode {
     fn from_meta(meta: &Meta) -> syn::Result<Self> {
         let pl = meta.assert_directive("number")?.as_path_list()?;
         let mut format = SetOnce::<NumberFormat>::new("format");
-        let mut endian = SetOnce::<Endianness>::new("endian").initial_value(Endianness::Little);
+        let mut endian = SetOnce::<Endianness>::new("endian").initial_value(Endianness::Le);
 
         pl.each(|ref meta| match meta.path_str().as_str() {
             "format" => {

codama-nodes/src/count_nodes/prefixed_count_node.rs

@@ -21,11 +21,11 @@ mod tests {
         let node = PrefixedCountNode::new(NumberTypeNode::le(U32));
         assert_eq!(
             node.prefix,
-            NestedTypeNode::Value(NumberTypeNode::new(U32, Endianness::Little))
+            NestedTypeNode::Value(NumberTypeNode::new(U32, Endianness::Le))
         );
         assert_eq!(
             node.prefix.get_nested_type_node(),
-            &NumberTypeNode::new(U32, Endianness::Little)
+            &NumberTypeNode::new(U32, Endianness::Le)
         );
     }
 
@@ -35,13 +35,13 @@ mod tests {
         assert_eq!(
             node.prefix,
             NestedTypeNode::PreOffset(PreOffsetTypeNode::absolute(
-                NestedTypeNode::Value(NumberTypeNode::new(U32, Endianness::Little)),
+                NestedTypeNode::Value(NumberTypeNode::new(U32, Endianness::Le)),
                 0
             ))
         );
         assert_eq!(
             node.prefix.get_nested_type_node(),
-            &NumberTypeNode::new(U32, Endianness::Little)
+            &NumberTypeNode::new(U32, Endianness::Le)
         );
     }
 

codama-nodes/src/generated/mod.rs

@@ -3,11 +3,13 @@ mod count_nodes;
 mod discriminator_nodes;
 mod link_nodes;
 mod pda_seed_nodes;
+mod shared;
 mod value_nodes;
 
 pub use contextual_value_nodes::*;
 pub use count_nodes::*;
 pub use discriminator_nodes::*;
 pub use link_nodes::*;
 pub use pda_seed_nodes::*;
+pub use shared::*;
 pub use value_nodes::*;

codama-nodes/src/generated/shared/bytes_encoding.rs

@@ -0,0 +1,15 @@
+use serde::{Deserialize, Serialize};
+
+/// How a string of bytes is encoded for transport.
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum BytesEncoding {
+    /// Hexadecimal encoding (two characters per byte).
+    Base16,
+    /// Base58 encoding, the standard for Solana addresses.
+    Base58,
+    /// Base64 encoding (RFC 4648).
+    Base64,
+    /// UTF-8 text encoding.
+    Utf8,
+}

codama-nodes/src/generated/shared/default_value_strategy.rs

@@ -0,0 +1,11 @@
+use serde::{Deserialize, Serialize};
+
+/// How an attribute that carries a default value is exposed in generated APIs.
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum DefaultValueStrategy {
+    /// The attribute is not exposed as a parameter in the generated API; the default value is always used.
+    Omitted,
+    /// The attribute is exposed as an optional parameter; callers may override the default value.
+    Optional,
+}

codama-nodes/src/generated/shared/endianness.rs

@@ -0,0 +1,11 @@
+use serde::{Deserialize, Serialize};
+
+/// The byte order of a numeric serialization.
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum Endianness {
+    /// Big-endian: the most significant byte is written first.
+    Be,
+    /// Little-endian: the least significant byte is written first.
+    Le,
+}

codama-nodes/src/generated/shared/instruction_lifecycle.rs

@@ -0,0 +1,15 @@
+use serde::{Deserialize, Serialize};
+
+/// The lifecycle stage of an instruction.
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum InstructionLifecycle {
+    /// No longer included in client SDKs. Retained in the IDL for historical reference only.
+    Archived,
+    /// Still callable but discouraged. Clients should migrate to a replacement instruction.
+    Deprecated,
+    /// Work-in-progress. The instruction may change before it stabilises.
+    Draft,
+    /// Stable and supported for production use.
+    Live,
+}

codama-nodes/src/generated/shared/mod.rs

@@ -0,0 +1,19 @@
+mod bytes_encoding;
+mod default_value_strategy;
+mod endianness;
+mod instruction_lifecycle;
+mod number_format;
+mod optional_account_strategy;
+mod post_offset_strategy;
+mod pre_offset_strategy;
+mod program_origin;
+
+pub use bytes_encoding::*;
+pub use default_value_strategy::*;
+pub use endianness::*;
+pub use instruction_lifecycle::*;
+pub use number_format::*;
+pub use optional_account_strategy::*;
+pub use post_offset_strategy::*;
+pub use pre_offset_strategy::*;
+pub use program_origin::*;

codama-nodes/src/generated/shared/number_format.rs

@@ -0,0 +1,33 @@
+use serde::{Deserialize, Serialize};
+
+/// The wire format of a numeric serialization.
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum NumberFormat {
+    /// IEEE-754 32-bit floating point.
+    F32,
+    /// IEEE-754 64-bit floating point.
+    F64,
+    /// Signed 8-bit integer.
+    I8,
+    /// Signed 16-bit integer.
+    I16,
+    /// Signed 32-bit integer.
+    I32,
+    /// Signed 64-bit integer.
+    I64,
+    /// Signed 128-bit integer.
+    I128,
+    /// Solana compact-u16 encoding: a variable-length unsigned integer occupying 1 to 3 bytes.
+    ShortU16,
+    /// Unsigned 8-bit integer.
+    U8,
+    /// Unsigned 16-bit integer.
+    U16,
+    /// Unsigned 32-bit integer.
+    U32,
+    /// Unsigned 64-bit integer.
+    U64,
+    /// Unsigned 128-bit integer.
+    U128,
+}

codama-nodes/src/generated/shared/optional_account_strategy.rs

@@ -0,0 +1,11 @@
+use serde::{Deserialize, Serialize};
+
+/// How an absent optional account is represented when serialising an instruction.
+#[derive(Debug, PartialEq, Eq, Clone, Copy, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum OptionalAccountStrategy {
+    /// The account slot is left out of the instruction entirely. Subsequent accounts shift up.
+    Omitted,
+    /// The account slot is filled with the program ID as a placeholder, preserving positional indices.
+    ProgramId,
+}