Struct SerializedAction 

pub struct SerializedAction {
    pub nullifier: [u8; 32],
    pub rk: [u8; 32],
    pub cmx: [u8; 32],
    pub encrypted_note: Vec<u8>,
    pub cv_net: [u8; 32],
    pub spend_auth_sig: [u8; 64],
}

A serialized Orchard action extracted from a bundle.

Each Orchard action structurally contains one spend and one output. The spend consumes a previously created note (revealing its nullifier), while the output creates a new note (publishing its commitment). Although paired in the same struct, observers cannot link which prior note was spent or what value the new note holds — the zero-knowledge proof ensures privacy.

These fields are raw bytes suitable for network serialization. During validation, they are parsed back into typed Orchard structs and verified via BatchValidator (Halo 2 proof + RedPallas signatures).

All fields except spend_auth_sig are covered by the Orchard bundle commitment (BLAKE2b-256 per ZIP-244), which feeds into the platform sighash. The signatures and proof are verified separately and are not part of the commitment.

Fields

nullifier: [u8; 32]

Unique tag derived from the spent note’s position and spending key. Published on-chain to prevent double-spends: if this nullifier already exists in the nullifier set, the transaction is rejected. The nullifier is deterministic for a given note but unlinkable to the note’s commitment, preserving sender privacy.

rk: [u8; 32]

Randomized spend validating key (RedPallas verification key). Derived from the spender’s full viewing key with per-action randomness. Used to verify spend_auth_sig, proving the spender controls the spending key for the consumed note without revealing which key it is.

cmx: [u8; 32]

Extracted note commitment for the newly created output note. This is added to the commitment tree after the transition is applied, allowing the recipient to later spend it. The commitment hides the note’s value, recipient, and randomness — only the recipient (who knows the decryption key) can identify and spend this note.

encrypted_note: Vec<u8>

Encrypted note ciphertext (216 bytes = epk 32 + enc_ciphertext 104 + out_ciphertext 80). Contains the TransmittedNoteCiphertext fields packed contiguously:

• epk: ephemeral public key for Diffie-Hellman key agreement (32 bytes)
• enc_ciphertext: note plaintext encrypted to the recipient (104 bytes = 52 compact + 36 memo + 16 AEAD tag)
• out_ciphertext: encrypted to the sender for wallet recovery (80 bytes)

Stored on-chain so recipients can scan and decrypt notes addressed to them. Only the intended recipient (or sender) can decrypt; all others see random bytes.

cv_net: [u8; 32]

Value commitment (Pedersen commitment to the note’s value). Commits to the value flowing through this action without revealing it. The binding signature later proves that the sum of all cv_net commitments across actions is consistent with the declared value_balance, ensuring no credits are created or destroyed.

spend_auth_sig: [u8; 64]

RedPallas spend authorization signature over the platform sighash. Proves the spender authorized this specific bundle (including all actions, value_balance, anchor, and any bound transparent fields). Verified against rk during batch validation. This prevents replay attacks — a valid signature from one transition cannot be reused in another.

Trait Implementations

impl<'__de, __Context> BorrowDecode<'__de, __Context> for SerializedAction

fn borrow_decode<__D: BorrowDecoder<'__de, Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given BorrowDecode.

impl Clone for SerializedAction

fn clone(&self) -> SerializedAction

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for SerializedAction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<__Context> Decode<__Context> for SerializedAction

fn decode<__D: Decoder<Context = __Context>>( decoder: &mut __D, ) -> Result<Self, DecodeError>

Attempt to decode this type with the given Decode.

impl<'de> Deserialize<'de> for SerializedAction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Encode for SerializedAction

fn encode<__E: Encoder>(&self, encoder: &mut __E) -> Result<(), EncodeError>

Encode a given type.

impl PartialEq for SerializedAction

fn eq(&self, other: &SerializedAction) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for SerializedAction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for SerializedAction