iota_sdk_types/transaction/

mod.rs

// Copyright (c) Mysten Labs, Inc.
// Modifications Copyright (c) 2025 IOTA Stiftung
// SPDX-License-Identifier: Apache-2.0

use std::collections::BTreeSet;

use super::{
    Address, CheckpointTimestamp, ConsensusCommitDigest, EpochId, Event, GenesisObject, Identifier,
    Intent, IntentMessage, MoveAuthenticator, ObjectId, ObjectReference, ProtocolVersion,
    TransactionDigest, TypeTag, UserSignature, Version,
};

mod randomness_round;
pub use randomness_round::RandomnessRound;

#[cfg(feature = "serde")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "serde")))]
mod serialization;
#[cfg(feature = "serde")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "serde")))]
pub(crate) use serialization::SignedTransactionWithIntentMessage;

/// Transaction
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// transaction = %d00 transaction-v1
///
/// transaction-v1 = transaction-kind address gas-payment transaction-expiration
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
#[non_exhaustive]
pub enum Transaction {
    V1(TransactionV1),
    // When new variants are introduced, it is important that we check version support
    // in the validity_check function based on the protocol config.
}

impl Transaction {
    crate::def_is_as_into_opt!(V1(TransactionV1));

    /// Wraps a reference to this transaction in the transaction signing
    /// intent, producing the message that user signatures commit to.
    pub fn intent_message(&self) -> IntentMessage<&Self> {
        IntentMessage::new(Intent::iota_transaction(), self)
    }
}

impl From<TransactionV1> for Transaction {
    fn from(v1: TransactionV1) -> Self {
        Transaction::V1(v1)
    }
}

impl crate::TreeDisplay for Transaction {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.enum_name("Transaction");
        match self {
            Self::V1(v1) => v1.fmt_tree(w),
        }
    }
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct TransactionV1 {
    pub kind: TransactionKind,
    pub sender: Address,
    pub gas_payment: GasPayment,
    pub expiration: TransactionExpiration,
}

impl crate::TreeDisplay for TransactionV1 {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Transaction V1")?;
        w.child("Kind", &self.kind, false)?;
        w.leaf("Sender", &self.sender, false)?;
        w.child("Gas Payment", &self.gas_payment, false)?;
        w.leaf("Expiration", &self.expiration, true)
    }
}

/// A [`SignedTransaction`] in its intent-message serialized form.
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// sender-signed-transaction = %d01 intent-signed-transaction
/// ```
#[derive(Clone, Debug, derive_more::Deref, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
pub struct SenderSignedTransaction(
    #[cfg_attr(
        feature = "serde",
        serde(with = "::serde_with::As::<crate::_serde::SignedTransactionWithIntentMessage>")
    )]
    SignedTransaction,
);

impl SenderSignedTransaction {
    pub fn new(transaction: Transaction, signatures: Vec<UserSignature>) -> Self {
        Self(SignedTransaction {
            transaction,
            signatures,
        })
    }

    /// The signed transaction carried by this intent message.
    pub fn signed_transaction(&self) -> &SignedTransaction {
        &self.0
    }

    /// Access the signed transaction carried by this intent message mutably.
    pub fn signed_transaction_mut(&mut self) -> &mut SignedTransaction {
        &mut self.0
    }

    /// Consume this intent message and return the signed transaction it
    /// carries.
    pub fn into_signed_transaction(self) -> SignedTransaction {
        self.0
    }
}

impl From<SignedTransaction> for SenderSignedTransaction {
    fn from(transaction: SignedTransaction) -> Self {
        Self(transaction)
    }
}

impl std::fmt::Display for SenderSignedTransaction {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.0)
    }
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct SignedTransaction {
    pub transaction: Transaction,
    pub signatures: Vec<UserSignature>,
}

impl SignedTransaction {
    pub fn transaction(&self) -> &Transaction {
        &self.transaction
    }

    pub fn signatures(&self) -> &[UserSignature] {
        &self.signatures
    }

    /// Wraps a reference to the transaction in the transaction signing
    /// intent, producing the message that the signatures commit to.
    pub fn intent_message(&self) -> IntentMessage<&Transaction> {
        self.transaction.intent_message()
    }

    /// Returns all [`MoveAuthenticator`] signatures.
    pub fn move_authenticators(&self) -> Vec<&MoveAuthenticator> {
        self.signatures
            .iter()
            .filter_map(|signature| signature.as_opt_move_authenticator())
            .collect()
    }

    /// Returns the sender's [`MoveAuthenticator`], if the sender uses one.
    pub fn sender_move_authenticator(&self) -> Option<&MoveAuthenticator> {
        let Transaction::V1(transaction) = &self.transaction;

        self.move_authenticators()
            .into_iter()
            .find(|authenticator| authenticator.address() == transaction.sender)
    }

    /// Returns the sponsor's [`MoveAuthenticator`], if the transaction is
    /// sponsored and the sponsor uses one.
    pub fn sponsor_move_authenticator(&self) -> Option<&MoveAuthenticator> {
        let Transaction::V1(transaction) = &self.transaction;
        let gas_owner = transaction.gas_payment.owner;

        if gas_owner != transaction.sender {
            self.move_authenticators()
                .into_iter()
                .find(|authenticator| authenticator.address() == gas_owner)
        } else {
            None
        }
    }
}

impl From<SenderSignedTransaction> for SignedTransaction {
    fn from(transaction: SenderSignedTransaction) -> Self {
        transaction.0
    }
}

impl crate::TreeDisplay for SignedTransaction {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Signed Transaction")?;
        w.child("Transaction", &self.transaction, false)?;
        w.children("Signatures", &self.signatures, true)
    }
}

/// A TTL for a transaction
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// transaction-expiration =  %d00      ; none
///                        =/ %d01 u64  ; epoch
/// ```
#[derive(Clone, Copy, Debug, Default, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
#[non_exhaustive]
pub enum TransactionExpiration {
    /// The transaction has no expiration
    #[default]
    None,
    /// Validators won't sign a transaction unless the expiration Epoch
    /// is greater than or equal to the current epoch
    Epoch(
        #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
        #[cfg_attr(feature = "bcs-schema", bcs_schema(as_type = "u64"))]
        EpochId,
    ),
}

impl TransactionExpiration {
    crate::def_is!(None);

    crate::def_is_as_into_opt!(Epoch(EpochId));
}

impl std::fmt::Display for TransactionExpiration {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            TransactionExpiration::None => write!(f, "None"),
            TransactionExpiration::Epoch(id) => write!(f, "Epoch({id})"),
        }
    }
}

/// Payment information for executing a transaction
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// gas-payment = (vector object-reference) ; gas coin objects
///               address                   ; owner
///               u64                       ; price
///               u64                       ; budget
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct GasPayment {
    pub objects: Vec<ObjectReference>,
    /// Owner of the gas objects, either the transaction sender or a sponsor
    pub owner: Address,
    /// Gas unit price to use when charging for computation
    ///
    /// Must be greater-than-or-equal-to the network's current RGP (reference
    /// gas price)
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub price: u64,
    /// Total budget willing to spend for the execution of a transaction
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub budget: u64,
}

impl crate::TreeDisplay for GasPayment {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Gas Payment")?;
        w.children("Objects", &self.objects, false)?;
        w.leaf("Owner", &self.owner, false)?;
        w.leaf("Price", &self.price, false)?;
        w.leaf("Budget", &self.budget, true)
    }
}

/// Randomness update
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// randomness-state-update = u64 randomness-round bytes version
/// ```
#[derive(Clone, derive_more::Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct RandomnessStateUpdate {
    /// Epoch of the randomness state update transaction
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub epoch: u64,
    /// Randomness round of the update
    pub randomness_round: RandomnessRound,
    /// Updated random bytes
    #[cfg_attr(
        feature = "serde",
        serde(with = "crate::_serde::ReadableBase64Encoded")
    )]
    #[debug("{:?}", <base64ct::Base64 as base64ct::Encoding>::encode_string(random_bytes))]
    pub random_bytes: Vec<u8>,
    /// The initial version of the randomness object that it was shared at.
    pub randomness_obj_initial_shared_version: Version,
}

impl crate::TreeDisplay for RandomnessStateUpdate {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Randomness State Update")?;
        w.leaf("Epoch", &self.epoch, false)?;
        w.leaf("Randomness Round", &self.randomness_round, false)?;
        w.leaf("Random Bytes", &hex::encode(&self.random_bytes), false)?;
        w.leaf(
            "Randomness Obj Initial Shared Version",
            &self.randomness_obj_initial_shared_version,
            true,
        )
    }
}

/// A complete set of transaction deny rules.
///
/// The set-typed deny lists encode in canonical form — ascending order
/// without duplicates — by construction, like BCS map keys. Note that
/// decoding normalizes: a non-canonical sequence encoding (unsorted or
/// duplicated elements) is accepted and sorted/deduplicated into the set, so
/// re-encoding it does not reproduce the original bytes.
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// deny-rule-set = (vector address)   ; denied addresses
///                 (vector object-id) ; denied objects
///                 (vector object-id) ; denied packages
///                 bool               ; package publish disabled
///                 bool               ; package upgrade disabled
///                 bool               ; shared object disabled
///                 bool               ; user transaction disabled
///                 bool               ; receiving objects disabled
///                 bool               ; move authenticator disabled
/// ```
#[derive(Clone, Debug, Default, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct DenyRuleSet {
    /// Addresses denied as transaction sender or gas sponsor. A denied
    /// address can still receive objects.
    pub denied_addresses: BTreeSet<Address>,
    /// Objects denied as transaction inputs or receiving objects.
    pub denied_objects: BTreeSet<ObjectId>,
    /// Packages denied as a (transitive) dependency of any command; upgrading
    /// a denied package is denied too.
    pub denied_packages: BTreeSet<ObjectId>,
    /// Denies all package publishing.
    pub package_publish_disabled: bool,
    /// Denies all package upgrades.
    pub package_upgrade_disabled: bool,
    /// Denies transactions that use shared objects as inputs.
    pub shared_object_disabled: bool,
    /// Denies all user transactions (kill switch).
    pub user_transaction_disabled: bool,
    /// Denies transactions that contain receiving objects.
    pub receiving_objects_disabled: bool,
    /// Denies transactions signed with a Move authenticator.
    pub move_authenticator_disabled: bool,
}

/// Update of the on-chain transaction deny rules.
///
/// Carries an add/remove delta for each deny list plus the absolute switch
/// states. The added and removed sets of a list are disjoint by producer
/// contract (validators compute them as a diff); a delta too large for one
/// transaction arrives split across several update transactions in the same
/// commit. Set-typed fields decode normalizing, like [`DenyRuleSet`]'s.
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// transaction-deny-rules-update = u64               ; epoch
///                                 u64               ; round
///                                 (vector address)  ; added addresses
///                                 (vector address)  ; removed addresses
///                                 (vector object-id) ; added objects
///                                 (vector object-id) ; removed objects
///                                 (vector object-id) ; added packages
///                                 (vector object-id) ; removed packages
///                                 bool              ; package publish disabled
///                                 bool              ; package upgrade disabled
///                                 bool              ; shared object disabled
///                                 bool              ; user transaction disabled
///                                 bool              ; receiving objects disabled
///                                 bool              ; move authenticator disabled
///                                 version           ; initial shared version
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct TransactionDenyRulesUpdate {
    /// Epoch of the deny-rules update transaction
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub epoch: u64,
    /// Consensus round of the update
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub round: u64,
    /// Addresses added to the sender-or-sponsor deny list.
    pub added_addresses: BTreeSet<Address>,
    /// Addresses removed from the sender-or-sponsor deny list.
    pub removed_addresses: BTreeSet<Address>,
    /// Objects added to the input-or-receiving deny list.
    pub added_objects: BTreeSet<ObjectId>,
    /// Objects removed from the input-or-receiving deny list.
    pub removed_objects: BTreeSet<ObjectId>,
    /// Packages added to the dependency deny list.
    pub added_packages: BTreeSet<ObjectId>,
    /// Packages removed from the dependency deny list.
    pub removed_packages: BTreeSet<ObjectId>,
    /// Denies all package publishing.
    pub package_publish_disabled: bool,
    /// Denies all package upgrades.
    pub package_upgrade_disabled: bool,
    /// Denies transactions that use shared objects as inputs.
    pub shared_object_disabled: bool,
    /// Denies all user transactions (kill switch).
    pub user_transaction_disabled: bool,
    /// Denies transactions that contain receiving objects.
    pub receiving_objects_disabled: bool,
    /// Denies transactions signed with a Move authenticator.
    pub move_authenticator_disabled: bool,
    /// The initial version of the deny-rules object that it was shared at.
    pub deny_rules_obj_initial_shared_version: Version,
}

impl crate::TreeDisplay for DenyRuleSet {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Deny Rule Set")?;
        w.leaves("Denied Addresses", &self.denied_addresses, false)?;
        w.leaves("Denied Objects", &self.denied_objects, false)?;
        w.leaves("Denied Packages", &self.denied_packages, false)?;
        w.leaf(
            "Package Publish Disabled",
            &self.package_publish_disabled,
            false,
        )?;
        w.leaf(
            "Package Upgrade Disabled",
            &self.package_upgrade_disabled,
            false,
        )?;
        w.leaf(
            "Shared Object Disabled",
            &self.shared_object_disabled,
            false,
        )?;
        w.leaf(
            "User Transaction Disabled",
            &self.user_transaction_disabled,
            false,
        )?;
        w.leaf(
            "Receiving Objects Disabled",
            &self.receiving_objects_disabled,
            false,
        )?;
        w.leaf(
            "Move Authenticator Disabled",
            &self.move_authenticator_disabled,
            true,
        )
    }
}

impl crate::TreeDisplay for TransactionDenyRulesUpdate {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Transaction Deny Rules Update")?;
        w.leaf("Epoch", &self.epoch, false)?;
        w.leaf("Round", &self.round, false)?;
        w.leaves("Added Addresses", &self.added_addresses, false)?;
        w.leaves("Removed Addresses", &self.removed_addresses, false)?;
        w.leaves("Added Objects", &self.added_objects, false)?;
        w.leaves("Removed Objects", &self.removed_objects, false)?;
        w.leaves("Added Packages", &self.added_packages, false)?;
        w.leaves("Removed Packages", &self.removed_packages, false)?;
        w.leaf(
            "Package Publish Disabled",
            &self.package_publish_disabled,
            false,
        )?;
        w.leaf(
            "Package Upgrade Disabled",
            &self.package_upgrade_disabled,
            false,
        )?;
        w.leaf(
            "Shared Object Disabled",
            &self.shared_object_disabled,
            false,
        )?;
        w.leaf(
            "User Transaction Disabled",
            &self.user_transaction_disabled,
            false,
        )?;
        w.leaf(
            "Receiving Objects Disabled",
            &self.receiving_objects_disabled,
            false,
        )?;
        w.leaf(
            "Move Authenticator Disabled",
            &self.move_authenticator_disabled,
            false,
        )?;
        w.leaf(
            "Deny Rules Obj Initial Shared Version",
            &self.deny_rules_obj_initial_shared_version,
            true,
        )
    }
}

/// Transaction type
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// transaction-kind    =  %d00 programmable-transaction               ; Programmable
///                     =/ %d01 genesis-transaction                    ; Genesis
///                     =/ %d02 consensus-commit-prologue-v1           ; ConsensusCommitPrologueV1
///                     =/ %d03                                        ; AuthenticatorStateUpdateV1Deprecated
///                     =/ %d04 (vector end-of-epoch-transaction-kind) ; EndOfEpoch
///                     =/ %d05 randomness-state-update                ; RandomnessStateUpdate
///                     =/ %d06 transaction-deny-rules-update          ; TransactionDenyRulesUpdate
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
#[non_exhaustive]
pub enum TransactionKind {
    /// A user transaction comprised of a list of native commands and move calls
    Programmable(ProgrammableTransaction),
    /// Transaction used to initialize the chain state.
    ///
    /// Only valid if in the genesis checkpoint (0) and if this is the very
    /// first transaction ever executed on the chain.
    Genesis(GenesisTransaction),
    /// V1 consensus commit update
    ConsensusCommitPrologueV1(ConsensusCommitPrologueV1),
    /// Update set of valid JWKs used for zklogin - Deprecated
    AuthenticatorStateUpdateV1Deprecated,
    /// Set of operations to run at the end of the epoch to close out the
    /// current epoch and start the next one.
    EndOfEpoch(Vec<EndOfEpochTransactionKind>),
    /// Randomness update
    RandomnessStateUpdate(RandomnessStateUpdate),
    /// Update of the on-chain transaction deny rules
    TransactionDenyRulesUpdate(TransactionDenyRulesUpdate),
}

impl TransactionKind {
    crate::def_is_as_into_opt! {
        ConsensusCommitPrologueV1,
        RandomnessStateUpdate,
        TransactionDenyRulesUpdate,
    }

    crate::def_is_as_into_opt! {
        Programmable(ProgrammableTransaction),
        Genesis(GenesisTransaction),
        EndOfEpoch(Vec<EndOfEpochTransactionKind>),
    }

    /// Create a [`TransactionKind::Programmable`].
    pub fn new_programmable(transaction: ProgrammableTransaction) -> Self {
        Self::Programmable(transaction)
    }

    /// Create a [`TransactionKind::Genesis`].
    pub fn new_genesis(transaction: GenesisTransaction) -> Self {
        Self::Genesis(transaction)
    }

    /// Create a [`TransactionKind::ConsensusCommitPrologueV1`].
    pub fn new_consensus_commit_prologue_v1(transaction: ConsensusCommitPrologueV1) -> Self {
        Self::ConsensusCommitPrologueV1(transaction)
    }

    /// Create a [`TransactionKind::EndOfEpoch`].
    pub fn new_end_of_epoch(transaction: Vec<EndOfEpochTransactionKind>) -> Self {
        Self::EndOfEpoch(transaction)
    }

    /// Create a [`TransactionKind::RandomnessStateUpdate`].
    pub fn new_randomness_state_update(transaction: RandomnessStateUpdate) -> Self {
        Self::RandomnessStateUpdate(transaction)
    }

    /// Create a [`TransactionKind::TransactionDenyRulesUpdate`].
    pub fn new_transaction_deny_rules_update(transaction: TransactionDenyRulesUpdate) -> Self {
        Self::TransactionDenyRulesUpdate(transaction)
    }

    /// Returns `true` if this is a system transaction.
    pub fn is_system(&self) -> bool {
        match self {
            TransactionKind::Genesis(_)
            | TransactionKind::ConsensusCommitPrologueV1(_)
            | TransactionKind::AuthenticatorStateUpdateV1Deprecated
            | TransactionKind::RandomnessStateUpdate(_)
            | TransactionKind::TransactionDenyRulesUpdate(_)
            | TransactionKind::EndOfEpoch(_) => true,
            TransactionKind::Programmable(_) => false,
        }
    }

    /// Returns the number of commands, or 0 if it is a system transaction.
    pub fn num_commands(&self) -> usize {
        match self {
            TransactionKind::Programmable(pt) => pt.commands.len(),
            _ => 0,
        }
    }

    /// Returns the number of transactions, or 1 if it is a system transaction.
    pub fn num_transactions(&self) -> usize {
        match self {
            TransactionKind::Programmable(pt) => pt.commands.len(),
            _ => 1,
        }
    }
}

impl crate::TreeDisplay for TransactionKind {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.enum_name("Transaction Kind");
        match self {
            Self::Programmable(pt) => pt.fmt_tree(w),
            Self::Genesis(v) => v.fmt_tree(w),
            Self::ConsensusCommitPrologueV1(v) => v.fmt_tree(w),
            Self::AuthenticatorStateUpdateV1Deprecated => {
                w.header("Authenticator State Update V1 (Deprecated)")
            }
            Self::EndOfEpoch(items) => {
                w.header("End of Epoch")?;
                w.children("Transactions", items, true)
            }
            Self::RandomnessStateUpdate(v) => v.fmt_tree(w),
            Self::TransactionDenyRulesUpdate(v) => v.fmt_tree(w),
        }
    }
}

/// Operation run at the end of an epoch
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// end-of-epoch-transaction-kind =  %d00 change-epoch     ; ChangeEpoch
///                               =/ %d01 change-epoch-v2  ; ChangeEpochV2
///                               =/ %d02 change-epoch-v3  ; ChangeEpochV3
///                               =/ %d03 change-epoch-v4  ; ChangeEpochV4
///                               =/ %d04                  ; TransactionDenyRulesCreate
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
#[non_exhaustive]
pub enum EndOfEpochTransactionKind {
    /// End the epoch and start the next one
    ChangeEpoch(ChangeEpoch),
    /// End the epoch and start the next one
    ChangeEpochV2(ChangeEpochV2),
    /// End the epoch and start the next one
    ChangeEpochV3(ChangeEpochV3),
    /// End the epoch and start the next one
    ChangeEpochV4(ChangeEpochV4),
    /// Create and share the transaction deny rules object
    TransactionDenyRulesCreate,
}

impl EndOfEpochTransactionKind {
    crate::def_is_as_into_opt!(ChangeEpoch, ChangeEpochV2, ChangeEpochV3, ChangeEpochV4,);

    crate::def_is!(TransactionDenyRulesCreate);

    /// Creates a [`ChangeEpoch`] end-of-epoch transaction kind.
    #[expect(clippy::too_many_arguments)]
    pub fn new_change_epoch(
        next_epoch: EpochId,
        protocol_version: ProtocolVersion,
        storage_charge: u64,
        computation_charge: u64,
        storage_rebate: u64,
        non_refundable_storage_fee: u64,
        epoch_start_timestamp_ms: u64,
        system_packages: Vec<SystemPackage>,
    ) -> Self {
        Self::ChangeEpoch(ChangeEpoch {
            epoch: next_epoch,
            protocol_version,
            storage_charge,
            computation_charge,
            storage_rebate,
            non_refundable_storage_fee,
            epoch_start_timestamp_ms,
            system_packages,
        })
    }

    /// Creates a [`ChangeEpochV2`] end-of-epoch transaction kind.
    #[expect(clippy::too_many_arguments)]
    pub fn new_change_epoch_v2(
        next_epoch: EpochId,
        protocol_version: ProtocolVersion,
        storage_charge: u64,
        computation_charge: u64,
        computation_charge_burned: u64,
        storage_rebate: u64,
        non_refundable_storage_fee: u64,
        epoch_start_timestamp_ms: u64,
        system_packages: Vec<SystemPackage>,
    ) -> Self {
        Self::ChangeEpochV2(ChangeEpochV2 {
            epoch: next_epoch,
            protocol_version,
            storage_charge,
            computation_charge,
            computation_charge_burned,
            storage_rebate,
            non_refundable_storage_fee,
            epoch_start_timestamp_ms,
            system_packages,
        })
    }

    /// Creates a [`ChangeEpochV3`] end-of-epoch transaction kind.
    #[expect(clippy::too_many_arguments)]
    pub fn new_change_epoch_v3(
        next_epoch: EpochId,
        protocol_version: ProtocolVersion,
        storage_charge: u64,
        computation_charge: u64,
        computation_charge_burned: u64,
        storage_rebate: u64,
        non_refundable_storage_fee: u64,
        epoch_start_timestamp_ms: u64,
        system_packages: Vec<SystemPackage>,
        eligible_active_validators: Vec<u64>,
    ) -> Self {
        Self::ChangeEpochV3(ChangeEpochV3 {
            epoch: next_epoch,
            protocol_version,
            storage_charge,
            computation_charge,
            computation_charge_burned,
            storage_rebate,
            non_refundable_storage_fee,
            epoch_start_timestamp_ms,
            system_packages,
            eligible_active_validators,
        })
    }

    /// Creates a [`ChangeEpochV4`] end-of-epoch transaction kind.
    #[expect(clippy::too_many_arguments)]
    pub fn new_change_epoch_v4(
        next_epoch: EpochId,
        protocol_version: ProtocolVersion,
        storage_charge: u64,
        computation_charge: u64,
        computation_charge_burned: u64,
        storage_rebate: u64,
        non_refundable_storage_fee: u64,
        epoch_start_timestamp_ms: u64,
        system_packages: Vec<SystemPackage>,
        eligible_active_validators: Vec<u64>,
        scores: Vec<u64>,
        adjust_rewards_by_score: bool,
    ) -> Self {
        Self::ChangeEpochV4(ChangeEpochV4 {
            epoch: next_epoch,
            protocol_version,
            storage_charge,
            computation_charge,
            computation_charge_burned,
            storage_rebate,
            non_refundable_storage_fee,
            epoch_start_timestamp_ms,
            system_packages,
            eligible_active_validators,
            scores,
            adjust_rewards_by_score,
        })
    }

    /// Creates a [`Self::TransactionDenyRulesCreate`] end-of-epoch transaction
    /// kind.
    pub fn new_transaction_deny_rules_create() -> Self {
        Self::TransactionDenyRulesCreate
    }

    /// Returns an iterator over the shared input objects required by this
    /// transaction kind.
    pub fn shared_input_objects(&self) -> impl Iterator<Item = SharedObjectReference> + '_ {
        match self {
            Self::ChangeEpoch(_)
            | Self::ChangeEpochV2(_)
            | Self::ChangeEpochV3(_)
            | Self::ChangeEpochV4(_) => {
                vec![SharedObjectReference::IOTA_SYSTEM_STATE_OBJ_MUTABLE].into_iter()
            }
            // The deny-rules object is created by this transaction, so there
            // is no shared input to reference yet.
            Self::TransactionDenyRulesCreate => vec![].into_iter(),
        }
    }
}

impl crate::TreeDisplay for EndOfEpochTransactionKind {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.enum_name("End of Epoch Transaction Kind");
        match self {
            Self::ChangeEpoch(v) => v.fmt_tree(w),
            Self::ChangeEpochV2(v) => v.fmt_tree(w),
            Self::ChangeEpochV3(v) => v.fmt_tree(w),
            Self::ChangeEpochV4(v) => v.fmt_tree(w),
            Self::TransactionDenyRulesCreate => w.header("Transaction Deny Rules Create"),
        }
    }
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
#[non_exhaustive]
pub enum ConsensusDeterminedVersionAssignments {
    /// Canceled transaction version assignment.
    CanceledTransactions {
        #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
        canceled_transactions: Vec<CanceledTransaction>,
    },
}

impl ConsensusDeterminedVersionAssignments {
    crate::def_is!(CanceledTransactions);

    pub fn as_canceled_transactions(&self) -> &[CanceledTransaction] {
        let Self::CanceledTransactions {
            canceled_transactions,
        } = self;
        canceled_transactions
    }
}

impl crate::TreeDisplay for ConsensusDeterminedVersionAssignments {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.enum_name("Consensus Determined Version Assignments");
        match self {
            ConsensusDeterminedVersionAssignments::CanceledTransactions {
                canceled_transactions,
            } => {
                w.header("Canceled Transactions")?;
                w.children("Transactions", canceled_transactions, true)
            }
        }
    }
}

/// A transaction that was canceled
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// canceled-transaction = transaction-digest (vector version-assignment)
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct CanceledTransaction {
    pub digest: TransactionDigest,
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
    pub version_assignments: Vec<VersionAssignment>,
}

impl crate::TreeDisplay for CanceledTransaction {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Canceled Transaction")?;
        w.leaf("Digest", &self.digest, false)?;
        w.children("Version Assignments", &self.version_assignments, true)
    }
}

/// Object version assignment from consensus
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the
/// following ABNF:
///
/// ```text
/// version-assignment = object-id u64
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct VersionAssignment {
    pub object_id: ObjectId,
    pub version: Version,
}

impl VersionAssignment {
    /// Creates a [`VersionAssignment`].
    pub fn new(object_id: ObjectId, version: Version) -> Self {
        Self { object_id, version }
    }
}

impl crate::TreeDisplay for VersionAssignment {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Version Assignment")?;
        w.leaf("Object ID", &self.object_id, false)?;
        w.leaf("Version", &self.version, true)
    }
}

/// V1 of the consensus commit prologue system transaction
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// consensus-commit-prologue-v1 = u64 u64 (option u64) u64 consensus-commit-digest
///                                consensus-determined-version-assignments
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct ConsensusCommitPrologueV1 {
    /// Epoch of the commit prologue transaction
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub epoch: u64,
    /// Consensus round of the commit
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub round: u64,
    /// The sub DAG index of the consensus commit. This field will be populated
    /// if there are multiple consensus commits per round.
    #[cfg_attr(
        feature = "serde",
        serde(with = "crate::_serde::OptionReadableDisplay")
    )]
    pub sub_dag_index: Option<u64>,
    /// Unix timestamp from consensus
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    #[cfg_attr(feature = "bcs-schema", bcs_schema(as_type = "u64"))]
    pub commit_timestamp_ms: CheckpointTimestamp,
    /// Digest of consensus output
    pub consensus_commit_digest: ConsensusCommitDigest,
    /// Stores consensus handler determined shared object version assignments.
    pub consensus_determined_version_assignments: ConsensusDeterminedVersionAssignments,
}

impl crate::TreeDisplay for ConsensusCommitPrologueV1 {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Consensus Commit Prologue V1")?;
        w.leaf("Epoch", &self.epoch, false)?;
        w.leaf("Round", &self.round, false)?;
        w.option_leaf("Sub DAG Index", &self.sub_dag_index, false)?;
        w.leaf("Commit Timestamp Ms", &self.commit_timestamp_ms, false)?;
        w.leaf(
            "Consensus Commit Digest",
            &self.consensus_commit_digest,
            false,
        )?;
        w.child(
            "Consensus Determined Version Assignments",
            &self.consensus_determined_version_assignments,
            true,
        )
    }
}

/// System transaction used to change the epoch
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// change-epoch = u64  ; next epoch
///                u64  ; protocol version
///                u64  ; storage charge
///                u64  ; computation charge
///                u64  ; storage rebate
///                u64  ; non-refundable storage fee
///                u64  ; epoch start timestamp
///                (vector system-package)
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct ChangeEpoch {
    /// The next (to become) epoch ID.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    #[cfg_attr(feature = "bcs-schema", bcs_schema(as_type = "u64"))]
    pub epoch: EpochId,
    /// The protocol version in effect in the new epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    #[cfg_attr(feature = "bcs-schema", bcs_schema(as_type = "u64"))]
    pub protocol_version: ProtocolVersion,
    /// The total amount of gas charged for storage during the epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub storage_charge: u64,
    /// The total amount of gas charged for computation during the epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub computation_charge: u64,
    /// The amount of storage rebate refunded to the txn senders.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub storage_rebate: u64,
    /// The non-refundable storage fee.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub non_refundable_storage_fee: u64,
    /// Unix timestamp when epoch started
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub epoch_start_timestamp_ms: u64,
    /// System packages (specifically framework and move stdlib) that are
    /// written before the new epoch starts. This tracks framework upgrades
    /// on chain. When executing the ChangeEpoch txn, the validator must
    /// write out the modules below.  Modules are provided with the version they
    /// will be upgraded to, their modules in serialized form (which include
    /// their package ID), and a list of their transitive dependencies.
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
    pub system_packages: Vec<SystemPackage>,
}

impl crate::TreeDisplay for ChangeEpoch {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Change Epoch")?;
        w.leaf("Epoch", &self.epoch, false)?;
        w.leaf("Protocol Version", &self.protocol_version, false)?;
        w.leaf("Storage Charge", &self.storage_charge, false)?;
        w.leaf("Computation Charge", &self.computation_charge, false)?;
        w.leaf("Storage Rebate", &self.storage_rebate, false)?;
        w.leaf(
            "Non-Refundable Storage Fee",
            &self.non_refundable_storage_fee,
            false,
        )?;
        w.leaf(
            "Epoch Start Timestamp Ms",
            &self.epoch_start_timestamp_ms,
            false,
        )?;
        w.children("System Packages", &self.system_packages, true)
    }
}

/// System transaction used to change the epoch
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// change-epoch-v2 = u64  ; next epoch
///                   u64  ; protocol version
///                   u64  ; storage charge
///                   u64  ; computation charge
///                   u64  ; computation charge burned
///                   u64  ; storage rebate
///                   u64  ; non-refundable storage fee
///                   u64  ; epoch start timestamp
///                   (vector system-package)
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct ChangeEpochV2 {
    /// The next (to become) epoch ID.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    #[cfg_attr(feature = "bcs-schema", bcs_schema(as_type = "u64"))]
    pub epoch: EpochId,
    /// The protocol version in effect in the new epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    #[cfg_attr(feature = "bcs-schema", bcs_schema(as_type = "u64"))]
    pub protocol_version: ProtocolVersion,
    /// The total amount of gas charged for storage during the epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub storage_charge: u64,
    /// The total amount of gas charged for computation during the epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub computation_charge: u64,
    /// The total amount of gas burned for computation during the epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub computation_charge_burned: u64,
    /// The amount of storage rebate refunded to the txn senders.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub storage_rebate: u64,
    /// The non-refundable storage fee.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub non_refundable_storage_fee: u64,
    /// Unix timestamp when epoch started
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub epoch_start_timestamp_ms: u64,
    /// System packages (specifically framework and move stdlib) that are
    /// written before the new epoch starts. This tracks framework upgrades
    /// on chain. When executing the ChangeEpoch txn, the validator must
    /// write out the modules below.  Modules are provided with the version they
    /// will be upgraded to, their modules in serialized form (which include
    /// their package ID), and a list of their transitive dependencies.
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
    pub system_packages: Vec<SystemPackage>,
}

impl crate::TreeDisplay for ChangeEpochV2 {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Change Epoch V2")?;
        w.leaf("Epoch", &self.epoch, false)?;
        w.leaf("Protocol Version", &self.protocol_version, false)?;
        w.leaf("Storage Charge", &self.storage_charge, false)?;
        w.leaf("Computation Charge", &self.computation_charge, false)?;
        w.leaf(
            "Computation Charge Burned",
            &self.computation_charge_burned,
            false,
        )?;
        w.leaf("Storage Rebate", &self.storage_rebate, false)?;
        w.leaf(
            "Non-Refundable Storage Fee",
            &self.non_refundable_storage_fee,
            false,
        )?;
        w.leaf(
            "Epoch Start Timestamp Ms",
            &self.epoch_start_timestamp_ms,
            false,
        )?;
        w.children("System Packages", &self.system_packages, true)
    }
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct ChangeEpochV3 {
    /// The next (to become) epoch ID.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    #[cfg_attr(feature = "bcs-schema", bcs_schema(as_type = "u64"))]
    pub epoch: EpochId,
    /// The protocol version in effect in the new epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    #[cfg_attr(feature = "bcs-schema", bcs_schema(as_type = "u64"))]
    pub protocol_version: ProtocolVersion,
    /// The total amount of gas charged for storage during the epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub storage_charge: u64,
    /// The total amount of gas charged for computation during the epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub computation_charge: u64,
    /// The total amount of gas burned for computation during the epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub computation_charge_burned: u64,
    /// The amount of storage rebate refunded to the txn senders.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub storage_rebate: u64,
    /// The non-refundable storage fee.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub non_refundable_storage_fee: u64,
    /// Unix timestamp when epoch started
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub epoch_start_timestamp_ms: u64,
    /// System packages (specifically framework and move stdlib) that are
    /// written before the new epoch starts. This tracks framework upgrades
    /// on chain. When executing the ChangeEpoch txn, the validator must
    /// write out the modules below.  Modules are provided with the version they
    /// will be upgraded to, their modules in serialized form (which include
    /// their package ID), and a list of their transitive dependencies.
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
    pub system_packages: Vec<SystemPackage>,
    /// Vector of active validator indices eligible to take part in committee
    /// selection because they support the new, target protocol version.
    pub eligible_active_validators: Vec<u64>,
}

impl crate::TreeDisplay for ChangeEpochV3 {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Change Epoch V3")?;
        w.leaf("Epoch", &self.epoch, false)?;
        w.leaf("Protocol Version", &self.protocol_version, false)?;
        w.leaf("Storage Charge", &self.storage_charge, false)?;
        w.leaf("Computation Charge", &self.computation_charge, false)?;
        w.leaf(
            "Computation Charge Burned",
            &self.computation_charge_burned,
            false,
        )?;
        w.leaf("Storage Rebate", &self.storage_rebate, false)?;
        w.leaf(
            "Non-Refundable Storage Fee",
            &self.non_refundable_storage_fee,
            false,
        )?;
        w.leaf(
            "Epoch Start Timestamp Ms",
            &self.epoch_start_timestamp_ms,
            false,
        )?;
        w.children("System Packages", &self.system_packages, false)?;
        w.leaves(
            "Eligible Active Validators",
            &self.eligible_active_validators,
            true,
        )
    }
}

#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct ChangeEpochV4 {
    /// The next (to become) epoch ID.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    #[cfg_attr(feature = "bcs-schema", bcs_schema(as_type = "u64"))]
    pub epoch: EpochId,
    /// The protocol version in effect in the new epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    #[cfg_attr(feature = "bcs-schema", bcs_schema(as_type = "u64"))]
    pub protocol_version: ProtocolVersion,
    /// The total amount of gas charged for storage during the epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub storage_charge: u64,
    /// The total amount of gas charged for computation during the epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub computation_charge: u64,
    /// The total amount of gas burned for computation during the epoch.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub computation_charge_burned: u64,
    /// The amount of storage rebate refunded to the txn senders.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub storage_rebate: u64,
    /// The non-refundable storage fee.
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub non_refundable_storage_fee: u64,
    /// Unix timestamp when epoch started
    #[cfg_attr(feature = "serde", serde(with = "crate::_serde::ReadableDisplay"))]
    pub epoch_start_timestamp_ms: u64,
    /// System packages (specifically framework and move stdlib) that are
    /// written before the new epoch starts. This tracks framework upgrades
    /// on chain. When executing the ChangeEpoch txn, the validator must
    /// write out the modules below.  Modules are provided with the version they
    /// will be upgraded to, their modules in serialized form (which include
    /// their package ID), and a list of their transitive dependencies.
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
    pub system_packages: Vec<SystemPackage>,
    /// Vector of active validator indices eligible to take part in committee
    /// selection because they support the new, target protocol version.
    pub eligible_active_validators: Vec<u64>,
    /// Vector of scores relative to the past epoch performance of each
    /// validator, ordered by the past epoch's validator index.
    pub scores: Vec<u64>,
    /// Whether to adjust validator rewards based on score.
    pub adjust_rewards_by_score: bool,
}

impl crate::TreeDisplay for ChangeEpochV4 {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Change Epoch V4")?;
        w.leaf("Epoch", &self.epoch, false)?;
        w.leaf("Protocol Version", &self.protocol_version, false)?;
        w.leaf("Storage Charge", &self.storage_charge, false)?;
        w.leaf("Computation Charge", &self.computation_charge, false)?;
        w.leaf(
            "Computation Charge Burned",
            &self.computation_charge_burned,
            false,
        )?;
        w.leaf("Storage Rebate", &self.storage_rebate, false)?;
        w.leaf(
            "Non-Refundable Storage Fee",
            &self.non_refundable_storage_fee,
            false,
        )?;
        w.leaf(
            "Epoch Start Timestamp Ms",
            &self.epoch_start_timestamp_ms,
            false,
        )?;
        w.children("System Packages", &self.system_packages, false)?;
        w.leaves(
            "Eligible Active Validators",
            &self.eligible_active_validators,
            false,
        )?;
        w.leaves("Scores", &self.scores, false)?;
        w.leaf(
            "Adjust Rewards By Score",
            &self.adjust_rewards_by_score,
            true,
        )
    }
}

#[derive(Clone, derive_more::Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct SystemPackage {
    pub version: Version,
    #[cfg_attr(
        feature = "serde",
        serde(
            with = "::serde_with::As::<Vec<::serde_with::IfIsHumanReadable<crate::_serde::Base64Encoded, ::serde_with::Bytes>>>"
        )
    )]
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
    #[debug(
        "{:?}",
        modules
            .iter()
            .map(|m| <base64ct::Base64 as base64ct::Encoding>::encode_string(m))
            .collect::<Vec<_>>()
    )]
    pub modules: Vec<Vec<u8>>,
    pub dependencies: Vec<ObjectId>,
}

impl crate::TreeDisplay for SystemPackage {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("System Package")?;
        w.leaf("Version", &self.version, false)?;
        w.base64_leaves("Modules", &self.modules, false)?;
        w.leaves("Dependencies", &self.dependencies, true)
    }
}

/// The genesis transaction
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// genesis-transaction = (vector genesis-object)
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct GenesisTransaction {
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
    pub objects: Vec<GenesisObject>,
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=10).lift()))]
    pub events: Vec<Event>,
}

impl crate::TreeDisplay for GenesisTransaction {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Genesis Transaction")?;
        w.children("Objects", &self.objects, false)?;
        w.children("Events", &self.events, true)
    }
}

/// A user transaction
///
/// Contains a series of native commands and move calls where the results of one
/// command can be used in future commands.
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// ptb = (vector input) (vector command)
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct ProgrammableTransaction {
    /// Input objects or primitive values
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=10).lift()))]
    pub inputs: Vec<Input>,
    /// The commands to be executed sequentially. A failure in any command will
    /// result in the failure of the entire transaction.
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=10).lift()))]
    pub commands: Vec<Command>,
}

impl crate::TreeDisplay for ProgrammableTransaction {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Programmable Transaction")?;
        w.children("Inputs", &self.inputs, false)?;
        w.children("Commands", &self.commands, true)
    }
}
/// An input to a user transaction
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// input = call-arg
///
/// call-arg   =  %d00 bytes        ; Pure
///            =/ %d01 object-arg   ; Object
///
/// object-arg =  %d00 object-reference     ; ImmutableOrOwned
///            =/ %d01 object-id u64 bool   ; Shared
///            =/ %d02 object-reference     ; Receiving
/// ```
#[derive(Clone, derive_more::Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(
    feature = "bcs-schema",
    derive(iota_bcs_schema::BcsSchema),
    bcs_schema(definition = "call-arg")
)]
#[non_exhaustive]
pub enum Input {
    /// A move value serialized as BCS.
    ///
    /// For normal operations this is required to be a move primitive type and
    /// not contain structs or objects.
    Pure(#[debug("{:?}", <base64ct::Base64 as base64ct::Encoding>::encode_string(_0))] Vec<u8>),
    /// A move object that is either immutable or address owned
    ImmutableOrOwned(ObjectReference),
    /// A move object whose owner is "Shared"
    Shared(SharedObjectReference),
    /// A move object that is attempted to be received in this transaction.
    // TODO add discussion around what receiving is
    Receiving(ObjectReference),
}

impl Input {
    /// Shared `Input` for the IOTA system state object.
    pub const IOTA_SYSTEM_MUTABLE: Self = Self::Shared(SharedObjectReference {
        object_id: ObjectId::SYSTEM_STATE,
        initial_shared_version: Version::INITIAL_SHARED_VERSION,
        mutable: true,
    });

    /// Shared `Input` for the clock object.
    pub const CLOCK_IMMUTABLE: Self = Self::Shared(SharedObjectReference {
        object_id: ObjectId::CLOCK,
        initial_shared_version: Version::INITIAL_SHARED_VERSION,
        mutable: false,
    });

    /// Shared `Input` for the clock object.
    pub const CLOCK_MUTABLE: Self = Self::Shared(SharedObjectReference {
        object_id: ObjectId::CLOCK,
        initial_shared_version: Version::INITIAL_SHARED_VERSION,
        mutable: true,
    });

    crate::def_is_as_into_opt!(
        Pure(Vec<u8>),
        ImmutableOrOwned(ObjectReference),
        Shared(SharedObjectReference),
        Receiving(ObjectReference)
    );

    /// Create a `Pure` input from a BCS-serializable value.
    #[cfg(feature = "serde")]
    #[cfg_attr(doc_cfg, doc(cfg(feature = "serde")))]
    pub fn pure<T: serde::Serialize>(value: &T) -> Self {
        Self::Pure(bcs::to_bytes(value).expect("value should be serializable"))
    }

    /// Returns the object id referenced by this input, if any.
    ///
    /// Returns `None` for `Pure` inputs.
    pub fn opt_object_id(&self) -> Option<&ObjectId> {
        match self {
            Self::Pure { .. } => None,
            Self::ImmutableOrOwned(obj_ref) | Self::Receiving(obj_ref) => Some(&obj_ref.object_id),
            Self::Shared(SharedObjectReference { object_id, .. }) => Some(object_id),
        }
    }

    /// Returns `true` if this input references a mutable shared object.
    pub fn is_mutable_shared(&self) -> bool {
        matches!(
            self,
            Self::Shared(SharedObjectReference { mutable: true, .. })
        )
    }

    /// Returns the [`ObjectReference`] if this is an `ImmutableOrOwned` or
    /// `Receiving` input.
    pub fn as_opt_object_ref(&self) -> Option<&ObjectReference> {
        match self {
            Self::ImmutableOrOwned(obj_ref) | Self::Receiving(obj_ref) => Some(obj_ref),
            _ => None,
        }
    }
}

impl crate::TreeDisplay for Input {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.enum_name("Input");
        match self {
            Self::Pure(value) => {
                w.header("Pure")?;
                w.leaf("Value", &hex::encode(value), true)
            }
            Self::ImmutableOrOwned(obj_ref) => {
                w.header("Immutable Or Owned")?;
                w.inline_child(obj_ref)
            }
            Self::Shared(shared) => {
                w.header("Shared")?;
                w.inline_child(shared)
            }
            Self::Receiving(obj_ref) => {
                w.header("Receiving")?;
                w.inline_child(obj_ref)
            }
        }
    }
}

/// A shared object input to a programmable transaction
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
pub struct SharedObjectReference {
    pub object_id: ObjectId,
    pub initial_shared_version: Version,
    /// Controls whether the caller asks for a mutable reference to the
    /// shared object.
    pub mutable: bool,
}

impl SharedObjectReference {
    pub const IOTA_SYSTEM_STATE_OBJ_MUTABLE: Self = Self {
        object_id: ObjectId::SYSTEM_STATE,
        initial_shared_version: Version::INITIAL_SHARED_VERSION,
        mutable: true,
    };

    /// Creates a new shared object reference from the object's id, initial
    /// shared version, and mutability.
    pub const fn new(object_id: ObjectId, initial_shared_version: Version, mutable: bool) -> Self {
        Self {
            object_id,
            initial_shared_version,
            mutable,
        }
    }
}

impl crate::TreeDisplay for SharedObjectReference {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Shared Object Reference")?;
        w.leaf("Object ID", &self.object_id, false)?;
        w.leaf(
            "Initial Shared Version",
            &self.initial_shared_version,
            false,
        )?;
        w.leaf("Mutable", &self.mutable, true)
    }
}

/// A single command in a programmable transaction.
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// command =  command-move-call
///         =/ command-transfer-objects
///         =/ command-split-coins
///         =/ command-merge-coins
///         =/ command-publish
///         =/ command-make-move-vector
///         =/ command-upgrade
///
/// command-move-call           = %d00 move-call
/// command-transfer-objects    = %d01 transfer-objects
/// command-split-coins         = %d02 split-coins
/// command-merge-coins         = %d03 merge-coins
/// command-publish             = %d04 publish
/// command-make-move-vector    = %d05 make-move-vector
/// command-upgrade             = %d06 upgrade
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
#[non_exhaustive]
pub enum Command {
    /// A call to either an entry or a public Move function
    MoveCall(MoveCall),
    /// `(Vec<forall T:key+store. T>, address)`
    /// It sends n-objects to the specified address. These objects must have
    /// store (public transfer) and either the previous owner must be an
    /// address or the object must be newly created.
    TransferObjects(TransferObjects),
    /// `(&mut Coin<T>, Vec<u64>)` -> `Vec<Coin<T>>`
    /// It splits off some amounts into a new coins with those amounts
    SplitCoins(SplitCoins),
    /// `(&mut Coin<T>, Vec<Coin<T>>)`
    /// It merges n-coins into the first coin
    MergeCoins(MergeCoins),
    /// Publishes a Move package. It takes the package bytes and a list of the
    /// package's transitive dependencies to link against on-chain.
    Publish(Publish),
    /// `forall T: Vec<T> -> vector<T>`
    /// Given n-values of the same type, it constructs a vector. For non objects
    /// or an empty vector, the type tag must be specified.
    MakeMoveVector(MakeMoveVector),
    /// Upgrades a Move package
    /// Takes (in order):
    /// 1. A vector of serialized modules for the package.
    /// 2. A vector of object ids for the transitive dependencies of the new
    ///    package.
    /// 3. The object ID of the package being upgraded.
    /// 4. An argument holding the `UpgradeTicket` that must have been produced
    ///    from an earlier command in the same programmable transaction.
    Upgrade(Upgrade),
}

impl Command {
    crate::def_is_as_into_opt!(
        MoveCall,
        TransferObjects,
        SplitCoins,
        MergeCoins,
        Publish,
        MakeMoveVector,
        Upgrade,
    );

    /// Create a command to call a Move function.
    pub fn new_move_call(
        package: ObjectId,
        module: Identifier,
        function: Identifier,
        type_arguments: Vec<TypeTag>,
        arguments: Vec<Argument>,
    ) -> Self {
        Command::MoveCall(MoveCall {
            package,
            module,
            function,
            type_arguments,
            arguments,
        })
    }

    /// Create a command to transfer objects to an address.
    pub fn new_transfer_objects(objects: Vec<Argument>, address: Argument) -> Self {
        Command::TransferObjects(TransferObjects { objects, address })
    }

    /// Create a command to split a coin into multiple coins by amounts.
    pub fn new_split_coins(coin: Argument, amounts: Vec<Argument>) -> Self {
        Command::SplitCoins(SplitCoins { coin, amounts })
    }

    /// Create a command to merge multiple coins into one.
    pub fn new_merge_coins(coin: Argument, coins_to_merge: Vec<Argument>) -> Self {
        Command::MergeCoins(MergeCoins {
            coin,
            coins_to_merge,
        })
    }

    /// Create a command to publish a new Move package.
    pub fn new_publish(modules: Vec<Vec<u8>>, dependencies: Vec<ObjectId>) -> Self {
        Command::Publish(Publish {
            modules,
            dependencies,
        })
    }

    /// Create a command to construct a Move vector from elements.
    pub fn new_make_move_vector(type_tag: Option<TypeTag>, elements: Vec<Argument>) -> Self {
        Command::MakeMoveVector(MakeMoveVector { type_tag, elements })
    }

    /// Create a command to upgrade an existing Move package.
    pub fn new_upgrade(
        modules: Vec<Vec<u8>>,
        dependencies: Vec<ObjectId>,
        package: ObjectId,
        ticket: Argument,
    ) -> Self {
        Command::Upgrade(Upgrade {
            modules,
            dependencies,
            package,
            ticket,
        })
    }
}

impl crate::TreeDisplay for Command {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.enum_name("Command");
        match self {
            Self::MoveCall(v) => v.fmt_tree(w),
            Self::TransferObjects(v) => v.fmt_tree(w),
            Self::SplitCoins(v) => v.fmt_tree(w),
            Self::MergeCoins(v) => v.fmt_tree(w),
            Self::Publish(v) => v.fmt_tree(w),
            Self::MakeMoveVector(v) => v.fmt_tree(w),
            Self::Upgrade(v) => v.fmt_tree(w),
        }
    }
}

/// Command to transfer ownership of a set of objects to an address
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// transfer-objects = (vector argument) argument
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct TransferObjects {
    /// Set of objects to transfer
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
    pub objects: Vec<Argument>,
    /// The address to transfer ownership to
    pub address: Argument,
}

impl crate::TreeDisplay for TransferObjects {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Transfer Objects")?;
        w.leaves("Objects", &self.objects, false)?;
        w.leaf("Address", &self.address, true)
    }
}

/// Command to split a single coin object into multiple coins
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// split-coins = argument (vector argument)
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct SplitCoins {
    /// The coin to split
    pub coin: Argument,
    /// The amounts to split off
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
    pub amounts: Vec<Argument>,
}

impl crate::TreeDisplay for SplitCoins {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Split Coins")?;
        w.leaf("Coin", &self.coin, false)?;
        w.leaves("Amounts", &self.amounts, true)
    }
}

/// Command to merge multiple coins of the same type into a single coin
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// merge-coins = argument (vector argument)
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct MergeCoins {
    /// Coin to merge coins into
    pub coin: Argument,
    /// Set of coins to merge into `coin`
    ///
    /// All listed coins must be of the same type and be the same type as `coin`
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
    pub coins_to_merge: Vec<Argument>,
}

impl crate::TreeDisplay for MergeCoins {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Merge Coins")?;
        w.leaf("Coin", &self.coin, false)?;
        w.leaves("Coins To Merge", &self.coins_to_merge, true)
    }
}

/// Command to publish a new move package
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// publish = (vector bytes)        ; the serialized move modules
///           (vector object-id)    ; the set of package dependencies
/// ```
#[derive(Clone, derive_more::Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct Publish {
    /// The serialized move modules
    #[cfg_attr(
        feature = "serde",
        serde(
            with = "::serde_with::As::<Vec<::serde_with::IfIsHumanReadable<crate::_serde::Base64Encoded, ::serde_with::Bytes>>>"
        )
    )]
    #[debug(
        "{:?}",
        modules
            .iter()
            .map(|m| <base64ct::Base64 as base64ct::Encoding>::encode_string(m))
            .collect::<Vec<_>>()
    )]
    pub modules: Vec<Vec<u8>>,
    /// Set of packages that the to-be published package depends on
    pub dependencies: Vec<ObjectId>,
}

impl crate::TreeDisplay for Publish {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Publish")?;
        w.base64_leaves("Modules", &self.modules, false)?;
        w.leaves("Dependencies", &self.dependencies, true)
    }
}

/// Command to build a move vector out of a set of individual elements
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// make-move-vector = (option type-tag) (vector argument)
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct MakeMoveVector {
    /// Type of the individual elements
    ///
    /// This is required to be set when the type can't be inferred, for example
    /// when the set of provided arguments are all pure input values.
    #[cfg_attr(feature = "serde", serde(rename = "type"))]
    pub type_tag: Option<TypeTag>,
    /// The set individual elements to build the vector with
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
    pub elements: Vec<Argument>,
}

impl crate::TreeDisplay for MakeMoveVector {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Make Move Vector")?;
        w.option_leaf("Type Tag", &self.type_tag, false)?;
        w.leaves("Elements", &self.elements, true)
    }
}

/// Command to upgrade an already published package
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// upgrade = (vector bytes)        ; move modules
///           (vector object-id)    ; dependencies
///           object-id             ; package-id of the package
///           argument              ; upgrade ticket
/// ```
#[derive(Clone, derive_more::Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct Upgrade {
    /// The serialized move modules
    #[cfg_attr(
        feature = "serde",
        serde(
            with = "::serde_with::As::<Vec<::serde_with::IfIsHumanReadable<crate::_serde::Base64Encoded, ::serde_with::Bytes>>>"
        )
    )]
    #[debug(
        "{:?}",
        modules
            .iter()
            .map(|m| <base64ct::Base64 as base64ct::Encoding>::encode_string(m))
            .collect::<Vec<_>>()
    )]
    pub modules: Vec<Vec<u8>>,
    /// Set of packages that the to-be published package depends on
    pub dependencies: Vec<ObjectId>,
    /// Package id of the package to upgrade
    pub package: ObjectId,
    /// Ticket authorizing the upgrade
    pub ticket: Argument,
}

impl crate::TreeDisplay for Upgrade {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Upgrade")?;
        w.base64_leaves("Modules", &self.modules, false)?;
        w.leaves("Dependencies", &self.dependencies, false)?;
        w.leaf("Package", &self.package, false)?;
        w.leaf("Ticket", &self.ticket, true)
    }
}

/// An argument to a programmable transaction command
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// argument    =  argument-gas
///             =/ argument-input
///             =/ argument-result
///             =/ argument-nested-result
///
/// argument-gas            = %d00
/// argument-input          = %d01 u16
/// argument-result         = %d02 u16
/// argument-nested-result  = %d03 u16 u16
/// ```
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
#[non_exhaustive]
pub enum Argument {
    /// The gas coin. The gas coin can only be used by-ref, except for with
    /// `TransferObjects`, which can use it by-value.
    Gas,
    /// One of the input objects or primitive values (from
    /// `ProgrammableTransaction` inputs)
    Input(u16),
    /// The result of another command (from `ProgrammableTransaction` commands)
    Result(u16),
    /// Like a `Result` but it accesses a nested result. Currently, the only
    /// usage of this is to access a value from a Move call with multiple
    /// return values.
    // (command index, subresult index)
    NestedResult(u16, u16),
}

impl std::fmt::Display for Argument {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Argument::Gas => write!(f, "Gas"),
            Argument::Input(i) => write!(f, "Input({i})"),
            Argument::Result(i) => write!(f, "Result({i})"),
            Argument::NestedResult(i, j) => write!(f, "NestedResult({i}, {j})"),
        }
    }
}

impl Argument {
    crate::def_is!(Gas, Input, Result, NestedResult);

    pub fn as_opt_input(&self) -> Option<u16> {
        if let Self::Input(idx) = self {
            Some(*idx)
        } else {
            None
        }
    }

    pub fn as_input(&self) -> u16 {
        self.as_opt_input().expect("not an input")
    }

    pub fn as_opt_result(&self) -> Option<u16> {
        if let Self::Result(idx) = self {
            Some(*idx)
        } else {
            None
        }
    }

    pub fn as_result(&self) -> u16 {
        self.as_opt_result().expect("not a result")
    }

    pub fn as_opt_nested_result(&self) -> Option<(u16, u16)> {
        if let Self::NestedResult(idx0, idx1) = self {
            Some((*idx0, *idx1))
        } else {
            None
        }
    }

    pub fn as_nested_result(&self) -> (u16, u16) {
        self.as_opt_nested_result().expect("not a nested result")
    }

    /// Get the nested result for this result at the given index. Returns None
    /// if this is not a Result.
    pub fn get_nested_result(&self, ix: u16) -> Option<Argument> {
        match self {
            Argument::Result(i) => Some(Argument::NestedResult(*i, ix)),
            _ => None,
        }
    }
}

/// Command to call a move function
///
/// Functions that can be called by a `MoveCall` command are those that have a
/// function signature that is either `entry` or `public` (which don't have a
/// reference return type).
///
/// # BCS
///
/// The BCS serialized form for this type is defined by the following ABNF:
///
/// ```text
/// move-call = object-id           ; package id
///             identifier          ; module name
///             identifier          ; function name
///             (vector type-tag)   ; type arguments, if any
///             (vector argument)   ; input arguments
/// ```
#[derive(Clone, Debug, Eq, Hash, PartialEq)]
#[cfg_attr(feature = "serde", derive(serde::Deserialize, serde::Serialize))]
#[cfg_attr(feature = "proptest", derive(test_strategy::Arbitrary))]
#[cfg_attr(feature = "bcs-schema", derive(iota_bcs_schema::BcsSchema))]
pub struct MoveCall {
    /// The package containing the module and function.
    pub package: ObjectId,
    /// The specific module in the package containing the function.
    #[cfg_attr(
        feature = "serde",
        serde(deserialize_with = "serialization::deserialize_ident_unchecked")
    )]
    pub module: Identifier,
    /// The function to be called.
    pub function: Identifier,
    /// The type arguments to the function.
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
    pub type_arguments: Vec<TypeTag>,
    /// The arguments to the function.
    #[cfg_attr(feature = "proptest", any(proptest::collection::size_range(0..=2).lift()))]
    pub arguments: Vec<Argument>,
}

impl crate::TreeDisplay for MoveCall {
    fn fmt_tree(&self, w: &mut crate::TreeWriter<'_, '_>) -> std::fmt::Result {
        w.header("Move Call")?;
        w.leaf("Package", &self.package, false)?;
        w.leaf("Module", &self.module, false)?;
        w.leaf("Function", &self.function, false)?;
        w.leaves("Type Arguments", &self.type_arguments, false)?;
        w.leaves("Arguments", &self.arguments, true)
    }
}

crate::impl_tree_display!(
    Transaction,
    DenyRuleSet,
    TransactionDenyRulesUpdate,
    TransactionV1,
    SignedTransaction,
    GasPayment,
    RandomnessStateUpdate,
    TransactionKind,
    EndOfEpochTransactionKind,
    ConsensusDeterminedVersionAssignments,
    CanceledTransaction,
    VersionAssignment,
    ConsensusCommitPrologueV1,
    ChangeEpoch,
    ChangeEpochV2,
    ChangeEpochV3,
    ChangeEpochV4,
    SystemPackage,
    GenesisTransaction,
    ProgrammableTransaction,
    SharedObjectReference,
    Input,
    Command,
    TransferObjects,
    SplitCoins,
    MergeCoins,
    Publish,
    MakeMoveVector,
    Upgrade,
    MoveCall,
);