Struct EntryFunction 

pub struct EntryFunction {
    pub module: MoveModuleId,
    pub function: String,
    pub type_args: Vec<TypeTag>,
    pub args: Vec<Vec<u8>>,
}

An entry function call payload.

Entry functions are the most common type of transaction payload. They call a function marked as entry in a Move module.

Example

use aptos_sdk::transaction::EntryFunction;
use aptos_sdk::types::{MoveModuleId, TypeTag, AccountAddress};

// Create a coin transfer payload
let module = MoveModuleId::from_str_strict("0x1::coin").unwrap();
let recipient = AccountAddress::from_hex("0x123").unwrap();
let entry_function = EntryFunction {
    module,
    function: "transfer".to_string(),
    type_args: vec![TypeTag::aptos_coin()],
    args: vec![
        aptos_bcs::to_bytes(&recipient).unwrap(),
        aptos_bcs::to_bytes(&1000u64).unwrap(),
    ],
};

Fields

module: MoveModuleId

The module containing the function.

function: String

The function name.

type_args: Vec<TypeTag>

Type arguments for generic functions.

args: Vec<Vec<u8>>

BCS-encoded arguments.

Implementations

impl EntryFunction

pub fn new( module: MoveModuleId, function: impl Into<String>, type_args: Vec<TypeTag>, args: Vec<Vec<u8>>, ) -> Self

Creates a new entry function payload.

pub fn from_function_id( function_id: &str, type_args: Vec<TypeTag>, args: Vec<Vec<u8>>, ) -> AptosResult<Self>

Creates an entry function from a function identifier string.

Arguments

• function_id - Full function ID (e.g., “0x1::coin::transfer”)
• type_args - Type arguments
• args - BCS-encoded arguments

Errors

Returns an error if the function ID string is invalid.

pub fn apt_transfer(recipient: AccountAddress, amount: u64) -> AptosResult<Self>

Creates a simple APT transfer payload.

Arguments

• recipient - The recipient’s address
• amount - Amount in octas (1 APT = 10^8 octas)

Errors

Returns an error if the module ID is invalid or if BCS encoding of arguments fails.

pub fn coin_transfer( coin_type: TypeTag, recipient: AccountAddress, amount: u64, ) -> AptosResult<Self>

Creates a coin transfer payload for any coin type.

Arguments

• coin_type - The coin type tag
• recipient - The recipient’s address
• amount - Amount in the coin’s smallest unit

Errors

Returns an error if the module ID is invalid or if BCS encoding of arguments fails.

Trait Implementations

impl Clone for EntryFunction

fn clone(&self) -> EntryFunction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EntryFunction

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EntryFunction

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<EntryFunction> for TransactionPayload

fn from(entry_function: EntryFunction) -> Self

Converts to this type from the input type.

impl PartialEq for EntryFunction

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

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

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

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

impl Serialize for EntryFunction

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for EntryFunction

impl StructuralPartialEq for EntryFunction