r402-tron 0.15.0

Tron chain support for the x402 payment protocol.
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

//! On-chain settlement logic for the Tron exact scheme.
//!
//! Builds, signs, broadcasts, and confirms `transferWithAuthorization` and
//! `x402ExactPermit2Proxy.settle` transactions via the `TronGrid` HTTP API.

use alloy_primitives::{Bytes, U256};
use alloy_sol_types::SolCall;

use super::signature::SignedMessage;
use super::{Eip3009Payment, Permit2Payment};
use crate::chain::TronChainReference;
use crate::chain::contracts::eip3009;
use crate::chain::contracts::x402_exact_permit2_proxy;
use crate::exact::TronExactError;

/// Settles a verified EIP-3009 payment by calling `transferWithAuthorization`
/// on the token contract via `TronGrid`.
pub(super) async fn settle_payment(
    provider: &crate::chain::TronChainProvider,
    payment: &Eip3009Payment,
    eip712_domain: &alloy_sol_types::Eip712Domain,
) -> Result<String, TronExactError> {
    let signed_message = SignedMessage::extract(payment, eip712_domain).map_err(|e| match e {
        super::signature::TronSignatureError::SignerMismatch => TronExactError::SignerMismatch,
        other => TronExactError::SignatureRecovery(other.to_string()),
    })?;
    let _ = &signed_message;

    // Build the calldata for transferWithAuthorization (bytes signature variant)
    let call = eip3009::transferWithAuthorizationCall {
        from: payment.from,
        to: payment.to,
        value: payment.value,
        validAfter: U256::from(payment.valid_after.as_secs()),
        validBefore: U256::from(payment.valid_before.as_secs()),
        nonce: payment.nonce,
        signature: payment.signature.clone(),
    };
    let calldata = eip3009::transferWithAuthorizationCall::abi_encode(&call);
    let token = eip712_domain
        .verifying_contract
        .ok_or(TronExactError::MissingTip712Domain)?;

    let tx_id = provider
        .send_contract_call(token, Bytes::from(calldata))
        .await?;
    Ok(tx_id)
}

/// Settles a verified Permit2 payment by calling `x402ExactPermit2Proxy.settle`
/// via `TronGrid`.
pub(super) async fn settle_permit2_payment(
    provider: &crate::chain::TronChainProvider,
    chain: &TronChainReference,
    payment: &Permit2Payment,
) -> Result<String, TronExactError> {
    let proxy_addr = chain
        .x402_exact_permit2_proxy()
        .ok_or(TronExactError::UnsupportedTransferMethod)?;

    let call = x402_exact_permit2_proxy::settleCall {
        permit: x402_exact_permit2_proxy::TronPermitTransferFrom {
            permitted: x402_exact_permit2_proxy::TronTokenPermissions {
                token: payment.token,
                amount: payment.amount,
            },
            nonce: payment.nonce,
            deadline: payment.deadline,
        },
        owner: payment.from,
        witness: x402_exact_permit2_proxy::TronWitness {
            to: payment.to,
            validAfter: payment.valid_after,
        },
        signature: payment.signature.clone(),
    };
    let calldata = x402_exact_permit2_proxy::settleCall::abi_encode(&call);

    let tx_id = provider
        .send_contract_call(proxy_addr.as_evm(), Bytes::from(calldata))
        .await?;
    Ok(tx_id)
}