aptos_sdk/transaction/

input.rs

//! Type-safe entry function payload builders.
//!
//! This module provides ergonomic builders for constructing entry function
//! payloads with automatic BCS encoding of arguments.
//!
//! # Overview
//!
//! `InputEntryFunctionData` provides a builder pattern that:
//! - Accepts Rust types directly (no manual BCS encoding)
//! - Validates function IDs at construction
//! - Supports all Move types
//!
//! # Example
//!
//! ```rust,ignore
//! use aptos_sdk::transaction::InputEntryFunctionData;
//!
//! // Simple transfer
//! let payload = InputEntryFunctionData::new("0x1::aptos_account::transfer")
//!     .arg(recipient_address)
//!     .arg(1_000_000u64)
//!     .build()?;
//!
//! // Generic function with type args
//! let payload = InputEntryFunctionData::new("0x1::coin::transfer")
//!     .type_arg("0x1::aptos_coin::AptosCoin")
//!     .arg(recipient_address)
//!     .arg(amount)
//!     .build()?;
//! ```

use crate::error::{AptosError, AptosResult};
use crate::transaction::{EntryFunction, TransactionPayload};
use crate::types::{AccountAddress, EntryFunctionId, MoveModuleId, TypeTag};
use serde::Serialize;

/// A type-safe builder for entry function payloads.
///
/// This builder provides an ergonomic way to construct entry function calls
/// with automatic BCS encoding of arguments.
///
/// # Example
///
/// ```rust,ignore
/// use aptos_sdk::transaction::InputEntryFunctionData;
/// use aptos_sdk::types::AccountAddress;
///
/// let payload = InputEntryFunctionData::new("0x1::aptos_account::transfer")
///     .arg(AccountAddress::from_hex("0x123").unwrap())
///     .arg(1_000_000u64)  // 0.01 APT in octas
///     .build()?;
/// ```
#[allow(dead_code)] // Public API struct - fields used via builder pattern
#[derive(Debug, Clone)]
pub struct InputEntryFunctionData {
    module: MoveModuleId,
    function: String,
    type_args: Vec<TypeTag>,
    args: Vec<Vec<u8>>,
}

impl InputEntryFunctionData {
    /// Creates a new entry function data builder.
    ///
    /// # Arguments
    ///
    /// * `function_id` - The full function identifier (e.g., "`0x1::coin::transfer`")
    ///
    /// # Example
    ///
    /// ```rust,ignore
    /// let builder = InputEntryFunctionData::new("0x1::aptos_account::transfer");
    /// ```
    #[allow(clippy::new_ret_no_self)] // Returns builder pattern intentionally
    pub fn new(function_id: &str) -> InputEntryFunctionDataBuilder {
        InputEntryFunctionDataBuilder::new(function_id)
    }

    /// Creates a builder from module and function name.
    ///
    /// # Arguments
    ///
    /// * `module` - The module ID
    /// * `function` - The function name
    pub fn from_parts(
        module: MoveModuleId,
        function: impl Into<String>,
    ) -> InputEntryFunctionDataBuilder {
        InputEntryFunctionDataBuilder {
            module: Ok(module),
            function: function.into(),
            type_args: Vec::new(),
            args: Vec::new(),
            errors: Vec::new(),
        }
    }

    /// Builds an APT transfer payload.
    ///
    /// # Arguments
    ///
    /// * `recipient` - The recipient address
    /// * `amount` - Amount in octas (1 APT = 10^8 octas)
    ///
    /// # Example
    ///
    /// ```rust,ignore
    /// let payload = InputEntryFunctionData::transfer_apt(recipient, 1_000_000)?;
    /// ```
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding of arguments fails.
    pub fn transfer_apt(recipient: AccountAddress, amount: u64) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::aptos_account::transfer")
            .arg(recipient)
            .arg(amount)
            .build()
    }

    /// Builds a coin transfer payload for any coin type.
    ///
    /// # Arguments
    ///
    /// * `coin_type` - The coin type (e.g., "`0x1::aptos_coin::AptosCoin`")
    /// * `recipient` - The recipient address
    /// * `amount` - Amount in the coin's smallest unit
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid, the coin type is invalid, or if BCS encoding of arguments fails.
    pub fn transfer_coin(
        coin_type: &str,
        recipient: AccountAddress,
        amount: u64,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::coin::transfer")
            .type_arg(coin_type)
            .arg(recipient)
            .arg(amount)
            .build()
    }

    /// Builds a fungible-asset transfer payload.
    ///
    /// Calls `0x1::primary_fungible_store::transfer`, moving `amount` units of
    /// the fungible asset identified by `metadata` (the address of its
    /// `0x1::fungible_asset::Metadata` object) from the sender's primary store
    /// to the recipient's primary store, creating the recipient's store if
    /// needed. This is the current (FA standard) counterpart to
    /// [`transfer_coin`](Self::transfer_coin) and matches the TypeScript SDK's
    /// `transferFungibleAsset`.
    ///
    /// # Arguments
    ///
    /// * `metadata` - Address of the fungible asset's `Metadata` object (e.g.
    ///   `0xa` for APT as a fungible asset).
    /// * `recipient` - The recipient address.
    /// * `amount` - Amount in the asset's smallest unit.
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID or type tag is invalid, or if BCS
    /// encoding of arguments fails.
    pub fn transfer_fungible_asset(
        metadata: AccountAddress,
        recipient: AccountAddress,
        amount: u64,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::primary_fungible_store::transfer")
            .type_arg("0x1::fungible_asset::Metadata")
            .arg(metadata)
            .arg(recipient)
            .arg(amount)
            .build()
    }

    /// Builds an account creation payload.
    ///
    /// # Arguments
    ///
    /// * `auth_key` - The authentication key (32 bytes)
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding of arguments fails.
    pub fn create_account(auth_key: AccountAddress) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::aptos_account::create_account")
            .arg(auth_key)
            .build()
    }

    /// Builds a payload to rotate an account's authentication key.
    ///
    /// # Arguments
    ///
    /// * Various rotation parameters
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding of arguments fails.
    pub fn rotate_authentication_key(
        from_scheme: u8,
        from_public_key_bytes: Vec<u8>,
        to_scheme: u8,
        to_public_key_bytes: Vec<u8>,
        cap_rotate_key: Vec<u8>,
        cap_update_table: Vec<u8>,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::account::rotate_authentication_key")
            .arg(from_scheme)
            .arg(from_public_key_bytes)
            .arg(to_scheme)
            .arg(to_public_key_bytes)
            .arg(cap_rotate_key)
            .arg(cap_update_table)
            .build()
    }

    /// Builds a payload to register a coin store.
    ///
    /// # Arguments
    ///
    /// * `coin_type` - The coin type to register
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid, the coin type is invalid, or if building the payload fails.
    pub fn register_coin(coin_type: &str) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::managed_coin::register")
            .type_arg(coin_type)
            .build()
    }

    /// Builds a payload to publish a module.
    ///
    /// # Arguments
    ///
    /// * `metadata_serialized` - Serialized module metadata
    /// * `code` - Vector of module bytecode
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding of arguments fails.
    pub fn publish_package(
        metadata_serialized: Vec<u8>,
        code: Vec<Vec<u8>>,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::code::publish_package_txn")
            .arg(metadata_serialized)
            .arg(code)
            .build()
    }

    // === Objects ===

    /// Builds a payload to transfer ownership of an object.
    ///
    /// Calls `0x1::object::transfer_call`, which moves the object at address
    /// `object` to `to`. Works for any object (including digital assets); for a
    /// typed transfer use [`transfer_digital_asset`](Self::transfer_digital_asset).
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding fails.
    pub fn transfer_object(
        object: AccountAddress,
        to: AccountAddress,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::object::transfer_call")
            .arg(object)
            .arg(to)
            .build()
    }

    // === Digital Assets (Token Objects) ===

    /// Builds a payload to transfer a digital asset (NFT) to another address.
    ///
    /// Calls `0x1::object::transfer` with the `0x4::token::Token` type, matching
    /// the TypeScript SDK's `transferDigitalAsset`.
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID or type tag is invalid or if BCS
    /// encoding fails.
    pub fn transfer_digital_asset(
        token: AccountAddress,
        to: AccountAddress,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::object::transfer")
            .type_arg("0x4::token::Token")
            .arg(token)
            .arg(to)
            .build()
    }

    /// Builds a payload to create a digital-asset collection
    /// (`0x4::aptos_token::create_collection`).
    ///
    /// `config` controls the collection/token mutability and burn/freeze
    /// permissions ([`CollectionConfig::default`] enables all of them, matching
    /// the most permissive TypeScript SDK defaults). `royalty_numerator /
    /// royalty_denominator` express the royalty as a fraction (use `0 / 1` for
    /// none).
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding fails.
    #[allow(clippy::too_many_arguments)]
    pub fn create_collection(
        description: &str,
        max_supply: u64,
        name: &str,
        uri: &str,
        config: CollectionConfig,
        royalty_numerator: u64,
        royalty_denominator: u64,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x4::aptos_token::create_collection")
            .arg(description)
            .arg(max_supply)
            .arg(name)
            .arg(uri)
            .arg(config.mutable_description)
            .arg(config.mutable_royalty)
            .arg(config.mutable_uri)
            .arg(config.mutable_token_description)
            .arg(config.mutable_token_name)
            .arg(config.mutable_token_properties)
            .arg(config.mutable_token_uri)
            .arg(config.tokens_burnable_by_creator)
            .arg(config.tokens_freezable_by_creator)
            .arg(royalty_numerator)
            .arg(royalty_denominator)
            .build()
    }

    /// Builds a payload to mint a digital asset into a collection
    /// (`0x4::aptos_token::mint`).
    ///
    /// The three property vectors must be equal length (a key, a Move type
    /// string, and BCS-encoded value per property); pass empty vectors for no
    /// properties.
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding fails.
    pub fn mint_digital_asset(
        collection: &str,
        description: &str,
        name: &str,
        uri: &str,
        property_keys: Vec<String>,
        property_types: Vec<String>,
        property_values: Vec<Vec<u8>>,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x4::aptos_token::mint")
            .arg(collection)
            .arg(description)
            .arg(name)
            .arg(uri)
            .arg(property_keys)
            .arg(property_types)
            .arg(property_values)
            .build()
    }

    /// Builds a payload to mint a soul-bound (non-transferable) digital asset
    /// (`0x4::aptos_token::mint_soul_bound`), bound to `soul_bound_to`.
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding fails.
    pub fn mint_soul_bound_digital_asset(
        collection: &str,
        description: &str,
        name: &str,
        uri: &str,
        property_keys: Vec<String>,
        property_types: Vec<String>,
        property_values: Vec<Vec<u8>>,
        soul_bound_to: AccountAddress,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x4::aptos_token::mint_soul_bound")
            .arg(collection)
            .arg(description)
            .arg(name)
            .arg(uri)
            .arg(property_keys)
            .arg(property_types)
            .arg(property_values)
            .arg(soul_bound_to)
            .build()
    }

    /// Builds a payload to burn a digital asset (`0x4::aptos_token::burn`).
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID or type tag is invalid or if BCS
    /// encoding fails.
    pub fn burn_digital_asset(token: AccountAddress) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x4::aptos_token::burn")
            .type_arg("0x4::token::Token")
            .arg(token)
            .build()
    }

    /// Builds a payload to freeze transfers of a digital asset
    /// (`0x4::aptos_token::freeze_transfer`).
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID or type tag is invalid or if BCS
    /// encoding fails.
    pub fn freeze_digital_asset_transfer(token: AccountAddress) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x4::aptos_token::freeze_transfer")
            .type_arg("0x4::token::Token")
            .arg(token)
            .build()
    }

    /// Builds a payload to unfreeze transfers of a digital asset
    /// (`0x4::aptos_token::unfreeze_transfer`).
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID or type tag is invalid or if BCS
    /// encoding fails.
    pub fn unfreeze_digital_asset_transfer(
        token: AccountAddress,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x4::aptos_token::unfreeze_transfer")
            .type_arg("0x4::token::Token")
            .arg(token)
            .build()
    }

    // === Staking (delegation pool) ===

    /// Builds a payload to add stake to a delegation pool
    /// (`0x1::delegation_pool::add_stake`).
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding fails.
    pub fn delegation_add_stake(
        pool_address: AccountAddress,
        amount: u64,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::delegation_pool::add_stake")
            .arg(pool_address)
            .arg(amount)
            .build()
    }

    /// Builds a payload to unlock stake from a delegation pool
    /// (`0x1::delegation_pool::unlock`). Unlocked stake becomes withdrawable
    /// after the pool's lockup expires.
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding fails.
    pub fn delegation_unlock(
        pool_address: AccountAddress,
        amount: u64,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::delegation_pool::unlock")
            .arg(pool_address)
            .arg(amount)
            .build()
    }

    /// Builds a payload to reactivate previously-unlocked stake
    /// (`0x1::delegation_pool::reactivate_stake`).
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding fails.
    pub fn delegation_reactivate_stake(
        pool_address: AccountAddress,
        amount: u64,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::delegation_pool::reactivate_stake")
            .arg(pool_address)
            .arg(amount)
            .build()
    }

    /// Builds a payload to withdraw unlocked stake from a delegation pool
    /// (`0x1::delegation_pool::withdraw`).
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding fails.
    pub fn delegation_withdraw(
        pool_address: AccountAddress,
        amount: u64,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::delegation_pool::withdraw")
            .arg(pool_address)
            .arg(amount)
            .build()
    }

    // === Account Abstraction (AIP-113) ===

    /// Builds a payload to enable account abstraction by registering a custom
    /// authentication function (`0x1::account_abstraction::add_authentication_function`).
    ///
    /// The function is identified by the module it lives in (`module_address` +
    /// `module_name`) and its `function_name`.
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding fails.
    pub fn add_authentication_function(
        module_address: AccountAddress,
        module_name: &str,
        function_name: &str,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::account_abstraction::add_authentication_function")
            .arg(module_address)
            .arg(module_name)
            .arg(function_name)
            .build()
    }

    /// Builds a payload to remove a previously-registered authentication
    /// function (`0x1::account_abstraction::remove_authentication_function`).
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding fails.
    pub fn remove_authentication_function(
        module_address: AccountAddress,
        module_name: &str,
        function_name: &str,
    ) -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::account_abstraction::remove_authentication_function")
            .arg(module_address)
            .arg(module_name)
            .arg(function_name)
            .build()
    }

    /// Builds a payload to fully disable account abstraction, removing all
    /// registered authentication functions
    /// (`0x1::account_abstraction::remove_authenticator`).
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid or if BCS encoding fails.
    pub fn remove_authenticator() -> AptosResult<TransactionPayload> {
        InputEntryFunctionData::new("0x1::account_abstraction::remove_authenticator").build()
    }
}

/// Mutability and permission configuration for
/// [`InputEntryFunctionData::create_collection`].
///
/// [`Default`] enables every mutability flag and both burn/freeze permissions,
/// matching the most permissive collection configuration. Set individual fields
/// to `false` to lock down a collection.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct CollectionConfig {
    /// Whether the collection description can be changed later.
    pub mutable_description: bool,
    /// Whether the collection royalty can be changed later.
    pub mutable_royalty: bool,
    /// Whether the collection URI can be changed later.
    pub mutable_uri: bool,
    /// Whether token descriptions can be changed later.
    pub mutable_token_description: bool,
    /// Whether token names can be changed later.
    pub mutable_token_name: bool,
    /// Whether token properties can be changed later.
    pub mutable_token_properties: bool,
    /// Whether token URIs can be changed later.
    pub mutable_token_uri: bool,
    /// Whether the creator may burn tokens in this collection.
    pub tokens_burnable_by_creator: bool,
    /// Whether the creator may freeze token transfers in this collection.
    pub tokens_freezable_by_creator: bool,
}

impl Default for CollectionConfig {
    fn default() -> Self {
        Self {
            mutable_description: true,
            mutable_royalty: true,
            mutable_uri: true,
            mutable_token_description: true,
            mutable_token_name: true,
            mutable_token_properties: true,
            mutable_token_uri: true,
            tokens_burnable_by_creator: true,
            tokens_freezable_by_creator: true,
        }
    }
}

/// Builder for `InputEntryFunctionData`.
#[derive(Debug, Clone)]
pub struct InputEntryFunctionDataBuilder {
    module: Result<MoveModuleId, String>,
    function: String,
    type_args: Vec<TypeTag>,
    args: Vec<Vec<u8>>,
    errors: Vec<String>,
}

impl InputEntryFunctionDataBuilder {
    /// Creates a new builder from a function ID string.
    #[must_use]
    fn new(function_id: &str) -> Self {
        match EntryFunctionId::from_str_strict(function_id) {
            Ok(func_id) => Self {
                module: Ok(func_id.module),
                function: func_id.name.as_str().to_string(),
                type_args: Vec::new(),
                args: Vec::new(),
                errors: Vec::new(),
            },
            Err(e) => Self {
                module: Err(format!("Invalid function ID '{function_id}': {e}")),
                function: String::new(),
                type_args: Vec::new(),
                args: Vec::new(),
                errors: Vec::new(),
            },
        }
    }

    /// Adds a type argument.
    ///
    /// # Arguments
    ///
    /// * `type_arg` - A type tag string (e.g., "`0x1::aptos_coin::AptosCoin`")
    ///
    /// # Example
    ///
    /// ```rust,ignore
    /// let builder = InputEntryFunctionData::new("0x1::coin::transfer")
    ///     .type_arg("0x1::aptos_coin::AptosCoin");
    /// ```
    #[must_use]
    pub fn type_arg(mut self, type_arg: &str) -> Self {
        match TypeTag::from_str_strict(type_arg) {
            Ok(tag) => self.type_args.push(tag),
            Err(e) => self
                .errors
                .push(format!("Invalid type argument '{type_arg}': {e}")),
        }
        self
    }

    /// Adds a type argument from a `TypeTag`.
    #[must_use]
    pub fn type_arg_typed(mut self, type_arg: TypeTag) -> Self {
        self.type_args.push(type_arg);
        self
    }

    /// Adds multiple type arguments.
    #[must_use]
    pub fn type_args(mut self, type_args: impl IntoIterator<Item = &'static str>) -> Self {
        for type_arg in type_args {
            self = self.type_arg(type_arg);
        }
        self
    }

    /// Adds multiple typed type arguments.
    #[must_use]
    pub fn type_args_typed(mut self, type_args: impl IntoIterator<Item = TypeTag>) -> Self {
        self.type_args.extend(type_args);
        self
    }

    /// Adds a BCS-encodable argument.
    ///
    /// Accepts any type that implements `Serialize` (BCS encoding).
    ///
    /// # Supported Types
    ///
    /// - Integers: `u8`, `u16`, `u32`, `u64`, `u128`
    /// - Boolean: `bool`
    /// - Strings: `String`, `&str`
    /// - Addresses: `AccountAddress`
    /// - Vectors: `Vec<T>` where T is serializable
    /// - Bytes: `Vec<u8>`, `&[u8]`
    ///
    /// # Example
    ///
    /// ```rust,ignore
    /// let builder = InputEntryFunctionData::new("0x1::my_module::my_function")
    ///     .arg(42u64)
    ///     .arg(true)
    ///     .arg(AccountAddress::ONE)
    ///     .arg("hello".to_string());
    /// ```
    #[must_use]
    pub fn arg<T: Serialize>(mut self, value: T) -> Self {
        match aptos_bcs::to_bytes(&value) {
            Ok(bytes) => self.args.push(bytes),
            Err(e) => self
                .errors
                .push(format!("Failed to serialize argument: {e}")),
        }
        self
    }

    /// Adds a raw BCS-encoded argument.
    ///
    /// Use this when you have pre-encoded bytes.
    #[must_use]
    pub fn arg_raw(mut self, bytes: Vec<u8>) -> Self {
        self.args.push(bytes);
        self
    }

    /// Adds multiple BCS-encodable arguments.
    #[must_use]
    pub fn args<T: Serialize>(mut self, values: impl IntoIterator<Item = T>) -> Self {
        for value in values {
            self = self.arg(value);
        }
        self
    }

    /// Builds the transaction payload.
    ///
    /// # Returns
    ///
    /// The constructed `TransactionPayload`, or an error if any
    /// validation or serialization failed.
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid, any type argument is invalid, or if any argument serialization failed.
    pub fn build(self) -> AptosResult<TransactionPayload> {
        // Check for module parsing error
        let module = self.module.map_err(AptosError::Transaction)?;

        // Check for any accumulated errors
        if !self.errors.is_empty() {
            return Err(AptosError::Transaction(self.errors.join("; ")));
        }

        Ok(TransactionPayload::EntryFunction(EntryFunction {
            module,
            function: self.function,
            type_args: self.type_args,
            args: self.args,
        }))
    }

    /// Builds just the entry function (without wrapping in `TransactionPayload`).
    ///
    /// # Errors
    ///
    /// Returns an error if the function ID is invalid, any type argument is invalid, or if any argument serialization failed.
    pub fn build_entry_function(self) -> AptosResult<EntryFunction> {
        let module = self.module.map_err(AptosError::Transaction)?;

        if !self.errors.is_empty() {
            return Err(AptosError::Transaction(self.errors.join("; ")));
        }

        Ok(EntryFunction {
            module,
            function: self.function,
            type_args: self.type_args,
            args: self.args,
        })
    }
}

/// Trait for types that can be converted to entry function arguments.
///
/// This trait is automatically implemented for types that implement `Serialize`.
pub trait IntoMoveArg {
    /// Converts this value into BCS-encoded bytes.
    ///
    /// # Errors
    ///
    /// Returns an error if BCS serialization fails.
    fn into_move_arg(self) -> AptosResult<Vec<u8>>;
}

impl<T: Serialize> IntoMoveArg for T {
    fn into_move_arg(self) -> AptosResult<Vec<u8>> {
        aptos_bcs::to_bytes(&self).map_err(AptosError::bcs)
    }
}

/// Helper to create a vector argument for Move functions.
///
/// Move vectors are BCS-encoded with a length prefix followed by elements.
///
/// # Example
///
/// ```rust,ignore
/// let addresses = move_vec(&[addr1, addr2, addr3]);
/// let amounts = move_vec(&[100u64, 200u64, 300u64]);
/// ```
pub fn move_vec<T: Serialize>(items: &[T]) -> Vec<u8> {
    aptos_bcs::to_bytes(items).unwrap_or_default()
}

/// Helper to create a string argument for Move functions.
///
/// Move strings are UTF-8 encoded vectors of bytes.
///
/// # Example
///
/// ```rust,ignore
/// let name = move_string("Alice");
/// ```
pub fn move_string(s: &str) -> String {
    s.to_string()
}

/// Helper to create an `Option::Some` argument for Move.
///
/// # Example
///
/// ```rust,ignore
/// let maybe_value = move_some(42u64);
/// ```
pub fn move_some<T: Serialize>(value: T) -> Vec<u8> {
    // BCS encodes Option as: 0x01 followed by the value bytes for Some
    let mut bytes = vec![0x01];
    if let Ok(value_bytes) = aptos_bcs::to_bytes(&value) {
        bytes.extend(value_bytes);
    }
    bytes
}

/// Helper to create an `Option::None` argument for Move.
///
/// # Example
///
/// ```rust,ignore
/// let maybe_value: Vec<u8> = move_none();
/// ```
pub fn move_none() -> Vec<u8> {
    // BCS encodes Option as: 0x00 for None
    vec![0x00]
}

/// A u256 value for Move arguments.
///
/// Move's u256 is a 256-bit unsigned integer, represented as 32 bytes in little-endian.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct MoveU256(pub [u8; 32]);

impl MoveU256 {
    /// Creates a `MoveU256` from a decimal string.
    ///
    /// # Errors
    ///
    /// Returns an error if the string cannot be parsed as a u256 value.
    pub fn parse(s: &str) -> AptosResult<Self> {
        // Parse as big integer and convert to little-endian bytes
        let mut bytes = [0u8; 32];

        // Simple parsing for small values
        if let Ok(val) = s.parse::<u128>() {
            bytes[..16].copy_from_slice(&val.to_le_bytes());
            return Ok(Self(bytes));
        }

        Err(AptosError::Transaction(format!("Invalid u256: {s}")))
    }

    /// Creates a `MoveU256` from a u128.
    pub fn from_u128(val: u128) -> Self {
        let mut bytes = [0u8; 32];
        bytes[..16].copy_from_slice(&val.to_le_bytes());
        Self(bytes)
    }

    /// Creates a `MoveU256` from raw bytes (little-endian).
    pub fn from_le_bytes(bytes: [u8; 32]) -> Self {
        Self(bytes)
    }
}

impl Serialize for MoveU256 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        // BCS serializes u256 as 32 little-endian bytes (as a tuple of bytes, not a vec)
        use serde::ser::SerializeTuple;
        let mut tuple = serializer.serialize_tuple(32)?;
        for byte in &self.0 {
            tuple.serialize_element(byte)?;
        }
        tuple.end()
    }
}

/// An i128 value for Move arguments.
///
/// Move's i128 is a 128-bit signed integer, represented as 16 bytes in little-endian
/// using two's complement representation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct MoveI128(pub i128);

impl MoveI128 {
    /// Creates a new `MoveI128` from an i128 value.
    pub fn new(val: i128) -> Self {
        Self(val)
    }
}

impl Serialize for MoveI128 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        // BCS serializes i128 as 16 little-endian bytes (two's complement)
        use serde::ser::SerializeTuple;
        let bytes = self.0.to_le_bytes();
        let mut tuple = serializer.serialize_tuple(16)?;
        for byte in &bytes {
            tuple.serialize_element(byte)?;
        }
        tuple.end()
    }
}

impl From<i128> for MoveI128 {
    fn from(val: i128) -> Self {
        Self(val)
    }
}

/// An i256 value for Move arguments.
///
/// Move's i256 is a 256-bit signed integer, represented as 32 bytes in little-endian
/// using two's complement representation.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct MoveI256(pub [u8; 32]);

impl MoveI256 {
    /// Creates a `MoveI256` from an i128 value.
    pub fn from_i128(val: i128) -> Self {
        let mut bytes = [0u8; 32];
        let val_bytes = val.to_le_bytes();
        bytes[..16].copy_from_slice(&val_bytes);
        // Sign extend for negative values
        if val < 0 {
            bytes[16..].fill(0xFF);
        }
        Self(bytes)
    }

    /// Creates a `MoveI256` from raw bytes (little-endian, two's complement).
    pub fn from_le_bytes(bytes: [u8; 32]) -> Self {
        Self(bytes)
    }
}

impl Serialize for MoveI256 {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        // BCS serializes i256 as 32 little-endian bytes (as a tuple of bytes, not a vec)
        use serde::ser::SerializeTuple;
        let mut tuple = serializer.serialize_tuple(32)?;
        for byte in &self.0 {
            tuple.serialize_element(byte)?;
        }
        tuple.end()
    }
}

impl From<i128> for MoveI256 {
    fn from(val: i128) -> Self {
        Self::from_i128(val)
    }
}

/// Common function IDs for convenience.
pub mod functions {
    /// APT transfer function.
    pub const APT_TRANSFER: &str = "0x1::aptos_account::transfer";
    /// Coin transfer function.
    pub const COIN_TRANSFER: &str = "0x1::coin::transfer";
    /// Account creation function.
    pub const CREATE_ACCOUNT: &str = "0x1::aptos_account::create_account";
    /// Register a coin store.
    pub const REGISTER_COIN: &str = "0x1::managed_coin::register";
    /// Publish a package.
    pub const PUBLISH_PACKAGE: &str = "0x1::code::publish_package_txn";
    /// Rotate authentication key.
    pub const ROTATE_AUTH_KEY: &str = "0x1::account::rotate_authentication_key";
}

/// Common type tags for convenience.
pub mod types {
    /// APT coin type.
    pub const APT_COIN: &str = "0x1::aptos_coin::AptosCoin";
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_simple_transfer() {
        let recipient = AccountAddress::from_hex("0x123").unwrap();
        let payload = InputEntryFunctionData::new("0x1::aptos_account::transfer")
            .arg(recipient)
            .arg(1_000_000u64)
            .build()
            .unwrap();

        match payload {
            TransactionPayload::EntryFunction(ef) => {
                assert_eq!(ef.function, "transfer");
                assert_eq!(ef.module.name.as_str(), "aptos_account");
                assert!(ef.type_args.is_empty());
                assert_eq!(ef.args.len(), 2);
            }
            _ => panic!("Expected EntryFunction"),
        }
    }

    #[test]
    fn test_with_type_args() {
        let payload = InputEntryFunctionData::new("0x1::coin::transfer")
            .type_arg("0x1::aptos_coin::AptosCoin")
            .arg(AccountAddress::ONE)
            .arg(1000u64)
            .build()
            .unwrap();

        match payload {
            TransactionPayload::EntryFunction(ef) => {
                assert_eq!(ef.function, "transfer");
                assert_eq!(ef.type_args.len(), 1);
            }
            _ => panic!("Expected EntryFunction"),
        }
    }

    #[test]
    fn test_invalid_function_id() {
        let result = InputEntryFunctionData::new("invalid").arg(42u64).build();

        assert!(result.is_err());
    }

    #[test]
    fn test_invalid_type_arg() {
        let result = InputEntryFunctionData::new("0x1::coin::transfer")
            .type_arg("not a type")
            .arg(AccountAddress::ONE)
            .arg(1000u64)
            .build();

        assert!(result.is_err());
    }

    #[test]
    fn test_transfer_apt_helper() {
        let recipient = AccountAddress::from_hex("0x456").unwrap();
        let payload = InputEntryFunctionData::transfer_apt(recipient, 5_000_000).unwrap();

        match payload {
            TransactionPayload::EntryFunction(ef) => {
                assert_eq!(ef.function, "transfer");
                assert_eq!(ef.module.name.as_str(), "aptos_account");
            }
            _ => panic!("Expected EntryFunction"),
        }
    }

    #[test]
    fn test_transfer_coin_helper() {
        let recipient = AccountAddress::from_hex("0x789").unwrap();
        let payload =
            InputEntryFunctionData::transfer_coin("0x1::aptos_coin::AptosCoin", recipient, 1000)
                .unwrap();

        match payload {
            TransactionPayload::EntryFunction(ef) => {
                assert_eq!(ef.function, "transfer");
                assert_eq!(ef.module.name.as_str(), "coin");
                assert_eq!(ef.type_args.len(), 1);
            }
            _ => panic!("Expected EntryFunction"),
        }
    }

    #[test]
    fn test_transfer_fungible_asset_helper() {
        let metadata = AccountAddress::from_hex("0xa").unwrap();
        let recipient = AccountAddress::from_hex("0x789").unwrap();
        let payload =
            InputEntryFunctionData::transfer_fungible_asset(metadata, recipient, 1000).unwrap();

        match payload {
            TransactionPayload::EntryFunction(ef) => {
                assert_eq!(ef.function, "transfer");
                assert_eq!(ef.module.name.as_str(), "primary_fungible_store");
                // One type argument: the Metadata object type.
                assert_eq!(ef.type_args.len(), 1);
                // Three args: metadata object address, recipient, amount.
                assert_eq!(ef.args.len(), 3);
                // The metadata `Object<Metadata>` is BCS-encoded as its address.
                assert_eq!(ef.args[0], aptos_bcs::to_bytes(&metadata).unwrap());
                assert_eq!(ef.args[2], aptos_bcs::to_bytes(&1000u64).unwrap());
            }
            _ => panic!("Expected EntryFunction"),
        }
    }

    #[test]
    fn test_transfer_object_helper() {
        let object = AccountAddress::from_hex("0xbeef").unwrap();
        let to = AccountAddress::from_hex("0x789").unwrap();
        let payload = InputEntryFunctionData::transfer_object(object, to).unwrap();
        match payload {
            TransactionPayload::EntryFunction(ef) => {
                assert_eq!(ef.module.name.as_str(), "object");
                assert_eq!(ef.function, "transfer_call");
                assert_eq!(ef.args.len(), 2);
                assert!(ef.type_args.is_empty());
            }
            _ => panic!("Expected EntryFunction"),
        }
    }

    #[test]
    fn test_transfer_digital_asset_helper() {
        let token = AccountAddress::from_hex("0xdead").unwrap();
        let to = AccountAddress::from_hex("0x789").unwrap();
        let payload = InputEntryFunctionData::transfer_digital_asset(token, to).unwrap();
        match payload {
            TransactionPayload::EntryFunction(ef) => {
                assert_eq!(ef.module.name.as_str(), "object");
                assert_eq!(ef.function, "transfer");
                assert_eq!(ef.type_args.len(), 1, "should carry the Token object type");
                assert_eq!(ef.args.len(), 2);
            }
            _ => panic!("Expected EntryFunction"),
        }
    }

    #[test]
    fn test_create_collection_arg_shape() {
        let payload = InputEntryFunctionData::create_collection(
            "desc",
            100,
            "My Collection",
            "https://example.com",
            CollectionConfig::default(),
            5,
            100,
        )
        .unwrap();
        match payload {
            TransactionPayload::EntryFunction(ef) => {
                assert_eq!(ef.module.address, AccountAddress::from_hex("0x4").unwrap());
                assert_eq!(ef.module.name.as_str(), "aptos_token");
                assert_eq!(ef.function, "create_collection");
                // 4 leading fields + 9 config flags + 2 royalty = 15 args.
                assert_eq!(ef.args.len(), 15);
            }
            _ => panic!("Expected EntryFunction"),
        }
    }

    #[test]
    fn test_mint_digital_asset_arg_shape() {
        let payload = InputEntryFunctionData::mint_digital_asset(
            "My Collection",
            "desc",
            "Token #1",
            "https://example.com/1",
            vec!["level".to_string()],
            vec!["u64".to_string()],
            vec![aptos_bcs::to_bytes(&1u64).unwrap()],
        )
        .unwrap();
        match payload {
            TransactionPayload::EntryFunction(ef) => {
                assert_eq!(ef.function, "mint");
                assert_eq!(ef.args.len(), 7);
            }
            _ => panic!("Expected EntryFunction"),
        }
    }

    #[test]
    fn test_delegation_helpers() {
        let pool = AccountAddress::from_hex("0x5").unwrap();
        for (payload, func) in [
            (
                InputEntryFunctionData::delegation_add_stake(pool, 1000).unwrap(),
                "add_stake",
            ),
            (
                InputEntryFunctionData::delegation_unlock(pool, 1000).unwrap(),
                "unlock",
            ),
            (
                InputEntryFunctionData::delegation_reactivate_stake(pool, 1000).unwrap(),
                "reactivate_stake",
            ),
            (
                InputEntryFunctionData::delegation_withdraw(pool, 1000).unwrap(),
                "withdraw",
            ),
        ] {
            match payload {
                TransactionPayload::EntryFunction(ef) => {
                    assert_eq!(ef.module.name.as_str(), "delegation_pool");
                    assert_eq!(ef.function, func);
                    assert_eq!(ef.args.len(), 2);
                }
                _ => panic!("Expected EntryFunction"),
            }
        }
    }

    #[test]
    fn test_account_abstraction_helpers() {
        let module = AccountAddress::from_hex("0x123").unwrap();
        let add =
            InputEntryFunctionData::add_authentication_function(module, "my_auth", "authenticate")
                .unwrap();
        match add {
            TransactionPayload::EntryFunction(ef) => {
                assert_eq!(ef.module.name.as_str(), "account_abstraction");
                assert_eq!(ef.function, "add_authentication_function");
                assert_eq!(ef.args.len(), 3);
            }
            _ => panic!("Expected EntryFunction"),
        }

        let remove_all = InputEntryFunctionData::remove_authenticator().unwrap();
        match remove_all {
            TransactionPayload::EntryFunction(ef) => {
                assert_eq!(ef.function, "remove_authenticator");
                assert!(ef.args.is_empty());
            }
            _ => panic!("Expected EntryFunction"),
        }
    }

    #[test]
    fn test_various_arg_types() {
        let payload = InputEntryFunctionData::new("0x1::test::test_function")
            .arg(42u8)
            .arg(1000u64)
            .arg(true)
            .arg("hello".to_string())
            .arg(vec![1u8, 2u8, 3u8])
            .arg(AccountAddress::ONE)
            .build()
            .unwrap();

        match payload {
            TransactionPayload::EntryFunction(ef) => {
                assert_eq!(ef.args.len(), 6);
            }
            _ => panic!("Expected EntryFunction"),
        }
    }

    #[test]
    fn test_move_u256() {
        let val = MoveU256::from_u128(12345);
        let bytes = aptos_bcs::to_bytes(&val).unwrap();
        assert_eq!(bytes.len(), 32);
    }

    #[test]
    fn test_move_some_none() {
        let some_bytes = move_some(42u64);
        assert_eq!(some_bytes[0], 0x01);

        let none_bytes = move_none();
        assert_eq!(none_bytes, vec![0x00]);
    }

    #[test]
    fn test_from_parts() {
        let module = MoveModuleId::from_str_strict("0x1::coin").unwrap();
        let payload = InputEntryFunctionData::from_parts(module, "transfer")
            .type_arg("0x1::aptos_coin::AptosCoin")
            .arg(AccountAddress::ONE)
            .arg(1000u64)
            .build()
            .unwrap();

        match payload {
            TransactionPayload::EntryFunction(ef) => {
                assert_eq!(ef.function, "transfer");
                assert_eq!(ef.module.name.as_str(), "coin");
            }
            _ => panic!("Expected EntryFunction"),
        }
    }

    #[test]
    fn test_build_entry_function() {
        let ef = InputEntryFunctionData::new("0x1::aptos_account::transfer")
            .arg(AccountAddress::ONE)
            .arg(1000u64)
            .build_entry_function()
            .unwrap();

        assert_eq!(ef.function, "transfer");
        assert_eq!(ef.args.len(), 2);
    }

    #[test]
    fn test_function_constants() {
        assert_eq!(functions::APT_TRANSFER, "0x1::aptos_account::transfer");
        assert_eq!(functions::COIN_TRANSFER, "0x1::coin::transfer");
    }

    #[test]
    fn test_move_u256_from_u128() {
        let val = MoveU256::from_u128(123_456_789);
        // First 16 bytes should contain the value in little-endian
        let expected = 123_456_789_u128.to_le_bytes();
        assert_eq!(&val.0[..16], &expected);
        // Upper 16 bytes should be zero
        assert_eq!(&val.0[16..], &[0u8; 16]);
    }

    #[test]
    fn test_move_u256_from_le_bytes() {
        let bytes = [0xab; 32];
        let val = MoveU256::from_le_bytes(bytes);
        assert_eq!(val.0, bytes);
    }

    #[test]
    fn test_move_u256_parse() {
        let val = MoveU256::parse("12345678901234567890").unwrap();
        let expected = 12_345_678_901_234_567_890_u128;
        let mut expected_bytes = [0u8; 32];
        expected_bytes[..16].copy_from_slice(&expected.to_le_bytes());
        assert_eq!(val.0, expected_bytes);
    }

    #[test]
    fn test_move_u256_parse_invalid() {
        // Value larger than u128 currently returns error
        let result = MoveU256::parse("999999999999999999999999999999999999999999999");
        assert!(result.is_err());
    }

    #[test]
    fn test_move_u256_serialization() {
        let val = MoveU256::from_u128(0x0102_0304_0506_0708);
        let bcs = aptos_bcs::to_bytes(&val).unwrap();
        // Should serialize as 32 bytes (tuple, not vector with length prefix)
        assert_eq!(bcs.len(), 32);
        // First 8 bytes should be our value in little-endian
        assert_eq!(&bcs[..8], &[0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]);
    }

    #[test]
    fn test_move_i128_new() {
        let val = MoveI128::new(42);
        assert_eq!(val.0, 42);
    }

    #[test]
    fn test_move_i128_from_i128() {
        let val: MoveI128 = (-100i128).into();
        assert_eq!(val.0, -100);
    }

    #[test]
    fn test_move_i128_serialization_positive() {
        let val = MoveI128::new(0x0102_0304_0506_0708);
        let bcs = aptos_bcs::to_bytes(&val).unwrap();
        // Should serialize as 16 bytes (tuple, not vector)
        assert_eq!(bcs.len(), 16);
        // First 8 bytes should be our value in little-endian
        assert_eq!(&bcs[..8], &[0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]);
        // Upper 8 bytes should be zeros for positive value
        assert_eq!(&bcs[8..], &[0, 0, 0, 0, 0, 0, 0, 0]);
    }

    #[test]
    fn test_move_i128_serialization_negative() {
        let val = MoveI128::new(-1);
        let bcs = aptos_bcs::to_bytes(&val).unwrap();
        assert_eq!(bcs.len(), 16);
        // -1 in two's complement is all 0xFF bytes
        assert_eq!(bcs, vec![0xFF; 16]);
    }

    #[test]
    fn test_move_i256_from_i128_positive() {
        let val = MoveI256::from_i128(42);
        // First 16 bytes should contain the value
        let expected = 42i128.to_le_bytes();
        assert_eq!(&val.0[..16], &expected);
        // Upper 16 bytes should be zeros for positive value
        assert_eq!(&val.0[16..], &[0u8; 16]);
    }

    #[test]
    fn test_move_i256_from_i128_negative() {
        let val = MoveI256::from_i128(-1);
        // -1 in two's complement should be all 0xFF bytes
        assert_eq!(val.0, [0xFF; 32]);
    }

    #[test]
    fn test_move_i256_from_le_bytes() {
        let bytes = [0xcd; 32];
        let val = MoveI256::from_le_bytes(bytes);
        assert_eq!(val.0, bytes);
    }

    #[test]
    fn test_move_i256_from_trait() {
        let val: MoveI256 = (-100i128).into();
        let expected = MoveI256::from_i128(-100);
        assert_eq!(val, expected);
    }

    #[test]
    fn test_move_i256_serialization() {
        let val = MoveI256::from_i128(0x0102_0304_0506_0708);
        let bcs = aptos_bcs::to_bytes(&val).unwrap();
        // Should serialize as 32 bytes (tuple, not vector)
        assert_eq!(bcs.len(), 32);
        // First 8 bytes should be our value in little-endian
        assert_eq!(&bcs[..8], &[0x08, 0x07, 0x06, 0x05, 0x04, 0x03, 0x02, 0x01]);
    }

    #[test]
    fn test_move_i256_serialization_negative() {
        let val = MoveI256::from_i128(-1);
        let bcs = aptos_bcs::to_bytes(&val).unwrap();
        assert_eq!(bcs.len(), 32);
        // -1 in two's complement is all 0xFF bytes
        assert_eq!(bcs, vec![0xFF; 32]);
    }

    /// Extracts the inner `EntryFunction` from a `TransactionPayload`, panicking
    /// for the test if the payload is not an entry-function variant.
    fn payload_as_entry_function(
        p: crate::transaction::TransactionPayload,
    ) -> crate::transaction::EntryFunction {
        match p {
            crate::transaction::TransactionPayload::EntryFunction(ef) => ef,
            other => panic!(
                "expected TransactionPayload::EntryFunction, got: {:?}",
                std::mem::discriminant(&other)
            ),
        }
    }

    #[test]
    fn test_input_entry_function_data_new() {
        let builder = InputEntryFunctionData::new("0x1::coin::transfer");
        let entry_fn = payload_as_entry_function(builder.build().expect("build should succeed"));
        assert_eq!(entry_fn.module.name.as_str(), "coin");
        assert_eq!(entry_fn.function, "transfer");
        assert!(entry_fn.type_args.is_empty());
        assert!(entry_fn.args.is_empty());
    }

    #[test]
    fn test_input_entry_function_data_invalid_function_id() {
        let builder = InputEntryFunctionData::new("invalid");
        let result = builder.build();
        assert!(result.is_err());
        assert!(
            result
                .unwrap_err()
                .to_string()
                .contains("Invalid function ID")
        );
    }

    #[test]
    fn test_input_entry_function_data_type_arg() {
        let entry_fn = payload_as_entry_function(
            InputEntryFunctionData::new("0x1::coin::transfer")
                .type_arg("0x1::aptos_coin::AptosCoin")
                .build()
                .expect("build should succeed"),
        );
        assert_eq!(entry_fn.type_args.len(), 1);
        assert_eq!(
            entry_fn.type_args[0].to_string(),
            "0x1::aptos_coin::AptosCoin"
        );
    }

    #[test]
    fn test_input_entry_function_data_invalid_type_arg() {
        let builder =
            InputEntryFunctionData::new("0x1::coin::transfer").type_arg("not a valid type");
        let result = builder.build();
        assert!(result.is_err());
        assert!(result.unwrap_err().to_string().contains("type argument"));
    }

    #[test]
    fn test_input_entry_function_data_type_arg_typed() {
        use crate::types::TypeTag;

        let entry_fn = payload_as_entry_function(
            InputEntryFunctionData::new("0x1::coin::transfer")
                .type_arg_typed(TypeTag::U64)
                .build()
                .expect("build should succeed"),
        );
        assert_eq!(entry_fn.type_args, vec![TypeTag::U64]);
    }

    #[test]
    fn test_input_entry_function_data_type_args() {
        let entry_fn = payload_as_entry_function(
            InputEntryFunctionData::new("0x1::coin::transfer")
                .type_args(["u64", "u128"])
                .build()
                .expect("build should succeed"),
        );
        assert_eq!(entry_fn.type_args.len(), 2);
        assert_eq!(entry_fn.type_args[0].to_string(), "u64");
        assert_eq!(entry_fn.type_args[1].to_string(), "u128");
    }

    #[test]
    fn test_input_entry_function_data_type_args_typed() {
        use crate::types::TypeTag;

        let entry_fn = payload_as_entry_function(
            InputEntryFunctionData::new("0x1::coin::transfer")
                .type_args_typed([TypeTag::U64, TypeTag::Bool])
                .build()
                .expect("build should succeed"),
        );
        assert_eq!(entry_fn.type_args, vec![TypeTag::U64, TypeTag::Bool]);
    }

    #[test]
    fn test_input_entry_function_data_arg() {
        let entry_fn = payload_as_entry_function(
            InputEntryFunctionData::new("0x1::coin::transfer")
                .arg(42u64)
                .arg(true)
                .arg("hello".to_string())
                .build()
                .expect("build should succeed"),
        );
        assert_eq!(entry_fn.args.len(), 3, "all three args must be present");
        // u64 BCS encodes 42 as 8 little-endian bytes: 0x2a 0x00 * 7
        assert_eq!(entry_fn.args[0][0], 42);
        // bool true is one byte: 0x01
        assert_eq!(entry_fn.args[1], vec![0x01]);
    }

    #[test]
    fn test_input_entry_function_data_arg_raw() {
        let raw_bytes = vec![0x01, 0x02, 0x03];
        let entry_fn = payload_as_entry_function(
            InputEntryFunctionData::new("0x1::coin::transfer")
                .arg_raw(raw_bytes.clone())
                .build()
                .expect("build should succeed"),
        );
        assert_eq!(entry_fn.args.len(), 1);
        assert_eq!(entry_fn.args[0], raw_bytes);
    }

    #[test]
    fn test_input_entry_function_data_args() {
        let entry_fn = payload_as_entry_function(
            InputEntryFunctionData::new("0x1::coin::transfer")
                .args([1u64, 2u64, 3u64])
                .build()
                .expect("build should succeed"),
        );
        assert_eq!(entry_fn.args.len(), 3);
        assert_eq!(entry_fn.args[0][0], 1);
        assert_eq!(entry_fn.args[1][0], 2);
        assert_eq!(entry_fn.args[2][0], 3);
    }

    #[test]
    fn test_input_entry_function_data_transfer_apt() {
        use crate::types::AccountAddress;

        let recipient = AccountAddress::from_hex("0x123").unwrap();
        let entry_fn = payload_as_entry_function(
            InputEntryFunctionData::transfer_apt(recipient, 1000)
                .expect("transfer_apt should succeed"),
        );
        assert_eq!(entry_fn.module.address, AccountAddress::ONE);
        assert_eq!(entry_fn.module.name.as_str(), "aptos_account");
        assert_eq!(entry_fn.function, "transfer");
        assert_eq!(entry_fn.args.len(), 2);
    }

    #[test]
    fn test_input_entry_function_data_builder_debug() {
        let builder = InputEntryFunctionData::new("0x1::coin::transfer");
        let debug = format!("{builder:?}");
        assert!(debug.contains("InputEntryFunctionDataBuilder"));
    }

    #[test]
    fn test_input_entry_function_data_builder_clone() {
        let builder = InputEntryFunctionData::new("0x1::coin::transfer").arg(42u64);
        let cloned = builder.clone();
        let original_built = payload_as_entry_function(builder.build().expect("original builds"));
        let cloned_built = payload_as_entry_function(cloned.build().expect("clone builds"));
        // Cloning produces a behaviourally-identical builder (same module, function, args).
        assert_eq!(original_built.module.name, cloned_built.module.name);
        assert_eq!(original_built.function, cloned_built.function);
        assert_eq!(original_built.args, cloned_built.args);
    }

    #[test]
    fn test_move_u256_debug() {
        let val = MoveU256::from_u128(123_456_789);
        let debug = format!("{val:?}");
        assert!(debug.contains("MoveU256"));
    }

    #[test]
    fn test_move_i128_debug() {
        let val = MoveI128::new(-42);
        let debug = format!("{val:?}");
        assert!(debug.contains("MoveI128"));
    }

    #[test]
    fn test_move_i256_debug() {
        let val = MoveI256::from_i128(-42);
        let debug = format!("{val:?}");
        assert!(debug.contains("MoveI256"));
    }

    #[test]
    fn test_move_u256_equality() {
        let val1 = MoveU256::from_u128(100);
        let val2 = MoveU256::from_u128(100);
        let val3 = MoveU256::from_u128(200);
        assert_eq!(val1, val2);
        assert_ne!(val1, val3);
    }

    #[test]
    fn test_move_i256_equality() {
        let val1 = MoveI256::from_i128(-50);
        let val2 = MoveI256::from_i128(-50);
        let val3 = MoveI256::from_i128(50);
        assert_eq!(val1, val2);
        assert_ne!(val1, val3);
    }

    #[test]
    fn test_move_u256_clone() {
        let val1 = MoveU256::from_u128(999);
        let val2 = val1;
        assert_eq!(val1, val2);
    }

    #[test]
    fn test_move_i256_clone() {
        let val1 = MoveI256::from_i128(-999);
        let val2 = val1;
        assert_eq!(val1, val2);
    }
}