Struct BurnMessageV2 

pub struct BurnMessageV2 {
    pub version: u32,
    pub burn_token: Address,
    pub mint_recipient: Address,
    pub amount: U256,
    pub message_sender: Address,
    pub max_fee: U256,
    pub fee_executed: U256,
    pub expiration_block: U256,
    pub hook_data: Bytes,
}

CCTP v2 Burn Message Body

The burn message body contains information about a token burn operation for cross-chain USDC transfers.

Format

• version: uint32 (4 bytes)
• burnToken: bytes32 (32 bytes) - address of token being burned
• mintRecipient: bytes32 (32 bytes) - address to receive minted tokens
• amount: uint256 (32 bytes) - amount being transferred
• messageSender: bytes32 (32 bytes) - original sender address
• maxFee: uint256 (32 bytes) - maximum fee willing to pay
• feeExecuted: uint256 (32 bytes) - actual fee charged
• expirationBlock: uint256 (32 bytes) - block number when message expires
• hookData: dynamic bytes - arbitrary data for destination chain hooks

Total fixed size: 4 + 32 + 32 + 32 + 32 + 32 + 32 + 32 = 228 bytes + dynamic hookData

Fields

version: u32

Message body version

burn_token: Address

Address of the token being burned (USDC contract)

mint_recipient: Address

Address that will receive minted tokens on destination chain

amount: U256

Amount of tokens being transferred (in wei/smallest unit)

message_sender: Address

Address of the original message sender

max_fee: U256

Maximum fee the sender is willing to pay (for Fast Transfers)

fee_executed: U256

Actual fee that was charged

expiration_block: U256

Block number after which the message expires (anti-replay protection)

hook_data: Bytes

Optional hook data for programmable transfers

Implementations

impl BurnMessageV2

pub const MIN_SIZE: usize = 228

Minimum size of the burn message body in bytes (without hookData)

pub fn new( burn_token: Address, mint_recipient: Address, amount: U256, message_sender: Address, ) -> Self

Creates a new burn message with standard settings (no fast transfer, no hooks)

pub fn new_with_fast_transfer( burn_token: Address, mint_recipient: Address, amount: U256, message_sender: Address, max_fee: U256, ) -> Self

Creates a new burn message with fast transfer settings

pub fn new_with_hooks( burn_token: Address, mint_recipient: Address, amount: U256, message_sender: Address, hook_data: Bytes, ) -> Self

Creates a new burn message with hook data

pub fn with_hook_data(self, hook_data: Bytes) -> Self

Sets the hook data for this message

pub fn with_max_fee(self, max_fee: U256) -> Self

Sets the maximum fee for fast transfer

pub fn with_expiration_block(self, expiration_block: U256) -> Self

Sets the expiration block

pub fn has_hooks(&self) -> bool

Returns true if this message has hook data

pub fn is_fast_transfer(&self) -> bool

Returns true if this message is configured for fast transfer (max_fee > 0)

Trait Implementations

impl Clone for BurnMessageV2

fn clone(&self) -> BurnMessageV2

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BurnMessageV2

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

Formats the value using the given formatter.

impl PartialEq for BurnMessageV2

fn eq(&self, other: &BurnMessageV2) -> 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 Eq for BurnMessageV2

impl StructuralPartialEq for BurnMessageV2