cctp-rs 3.0.0

Rust SDK for CCTP
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108

// SPDX-FileCopyrightText: 2025 Semiotic AI, Inc.
//
// SPDX-License-Identifier: Apache-2.0
//! `TokenMessenger` contract bindings and wrapper
//!
//! This module contains the Alloy-generated contract bindings for the CCTP
//! `TokenMessenger` contract, which manages USDC burn and mint operations for
//! cross-chain transfers.

use std::marker::PhantomData;

use alloy_contract::CallBuilder;
use alloy_network::Ethereum;
use alloy_primitives::{Address, U256};
use alloy_provider::Provider;
use alloy_rpc_types::TransactionRequest;
use alloy_sol_types::sol;
use tracing::{debug, info};
use TokenMessenger::{depositForBurnCall, TokenMessengerInstance};

use crate::spans;

/// The CCTP v1 Token Messenger contract wrapper
pub struct TokenMessengerContract<P: Provider<Ethereum>> {
    instance: TokenMessengerInstance<P>,
}

impl<P: Provider<Ethereum>> TokenMessengerContract<P> {
    /// Create a new `TokenMessengerContract`.
    pub fn new(address: Address, provider: P) -> Self {
        debug!(
            contract_address = %address,
            event = "token_messenger_contract_initialized"
        );
        Self {
            instance: TokenMessengerInstance::new(address, provider),
        }
    }

    /// Create the call builder for the `depositForBurn` function.
    ///
    /// Most users will want to use the `deposit_for_burn_transaction` function instead.
    pub fn deposit_for_burn_call_builder(
        &self,
        from_address: Address,
        recipient: Address,
        destination_domain: u32,
        token_address: Address,
        amount: U256,
    ) -> CallBuilder<&P, PhantomData<depositForBurnCall>> {
        self.instance
            .depositForBurn(
                amount,
                destination_domain,
                recipient.into_word(),
                token_address,
            )
            .from(from_address)
    }

    /// Create the transaction request for the `depositForBurn` function.
    ///
    /// Most users will want to use this function instead of the `deposit_for_burn_call_builder` function.
    pub fn deposit_for_burn_transaction(
        &self,
        from_address: Address,
        recipient: Address,
        destination_domain: u32,
        token_address: Address,
        amount: U256,
    ) -> TransactionRequest {
        let span = spans::deposit_for_burn(
            &from_address,
            &recipient,
            destination_domain,
            &token_address,
            &amount,
        );
        let _guard = span.enter();

        info!(
            from_address = %from_address,
            recipient = %recipient,
            destination_domain = destination_domain,
            token_address = %token_address,
            amount = %amount,
            contract_address = %self.instance.address(),
            event = "deposit_for_burn_transaction_created"
        );

        self.deposit_for_burn_call_builder(
            from_address,
            recipient,
            destination_domain,
            token_address,
            amount,
        )
        .into_transaction_request()
    }
}

sol!(
    #[allow(clippy::too_many_arguments)]
    #[allow(missing_docs)]
    #[sol(rpc)]
    TokenMessenger,
    "abis/v1_token_messenger.json"
);