Struct light_system_program::invoke::instruction::InstructionDataInvoke

pub struct InstructionDataInvoke {
    pub proof: Option<CompressedProof>,
    pub input_root_indices: Vec<u16>,
    pub input_compressed_accounts_with_merkle_context: Vec<PackedCompressedAccountWithMerkleContext>,
    pub output_compressed_accounts: Vec<CompressedAccount>,
    pub output_state_merkle_tree_account_indices: Vec<u8>,
    pub relay_fee: Option<u64>,
    pub new_address_params: Vec<NewAddressParamsPacked>,
    pub compression_lamports: Option<u64>,
    pub is_compress: bool,
}

Fields

proof: Option<CompressedProof>

input_root_indices: Vec<u16>

input_compressed_accounts_with_merkle_context: Vec<PackedCompressedAccountWithMerkleContext>

output_compressed_accounts: Vec<CompressedAccount>

output_state_merkle_tree_account_indices: Vec<u8>

The indices of the accounts in the output state merkle tree.

relay_fee: Option<u64>

new_address_params: Vec<NewAddressParamsPacked>

compression_lamports: Option<u64>

is_compress: bool

Implementations

impl InstructionDataInvoke

pub fn check_input_lengths(&self) -> Result<()>

Checks that the lengths of the vectors are consistent with each other. Note that this function does not check the inputs themselves just plausible of the lengths. input roots must be the same length as input compressed accounts output compressed accounts must be the same length as output state merkle tree account indices

Trait Implementations

impl BorshDeserialize for InstructionDataInvoke

where Option<CompressedProof>: BorshDeserialize, Vec<u16>: BorshDeserialize, Vec<PackedCompressedAccountWithMerkleContext>: BorshDeserialize, Vec<CompressedAccount>: BorshDeserialize, Vec<u8>: BorshDeserialize, Option<u64>: BorshDeserialize, Vec<NewAddressParamsPacked>: BorshDeserialize, bool: BorshDeserialize,

fn deserialize_reader<R: Read>(reader: &mut R) -> Result<Self, Error>

fn deserialize(buf: &mut &[u8]) -> Result<Self, Error>

Deserializes this instance from a given slice of bytes. Updates the buffer to point at the remaining bytes.

fn try_from_slice(v: &[u8]) -> Result<Self, Error>

Deserialize this instance from a slice of bytes.

fn try_from_reader<R>(reader: &mut R) -> Result<Self, Error>

where R: Read,

impl BorshSerialize for InstructionDataInvoke

where Option<CompressedProof>: BorshSerialize, Vec<u16>: BorshSerialize, Vec<PackedCompressedAccountWithMerkleContext>: BorshSerialize, Vec<CompressedAccount>: BorshSerialize, Vec<u8>: BorshSerialize, Option<u64>: BorshSerialize, Vec<NewAddressParamsPacked>: BorshSerialize, bool: BorshSerialize,

fn serialize<W: Write>(&self, writer: &mut W) -> Result<(), Error>

fn try_to_vec(&self) -> Result<Vec<u8>, Error>

Serialize this instance into a vector of bytes.

impl Clone for InstructionDataInvoke

fn clone(&self) -> InstructionDataInvoke

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for InstructionDataInvoke

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

Formats the value using the given formatter.

impl Default for InstructionDataInvoke

fn default() -> InstructionDataInvoke

Returns the “default value” for a type.

impl PartialEq for InstructionDataInvoke

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for InstructionDataInvoke