x402-chain-eip155 1.5.6

EIP-155 (EVM) 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
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
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use alloy_provider::Provider;
use alloy_sol_types::Eip712Domain;
use x402_types::chain::{ChainId, ChainProviderOps};
use x402_types::proto::{PaymentVerificationError, v2};
use x402_types::scheme::X402SchemeFacilitatorError;

#[cfg(feature = "telemetry")]
use tracing::instrument;

use crate::chain::{Eip155ChainReference, Eip155MetaTransactionProvider};
use crate::v1_eip155_exact::{
    Eip155ExactError, ExactEvmPayment, IEIP3009, PaymentRequirementsExtra, assert_domain,
    assert_enough_balance, assert_enough_value, assert_time, settle_payment, verify_payment,
};
use crate::v2_eip155_exact::Eip3009Payload;
use crate::v2_eip155_exact::types::{Eip3009PaymentPayload, Eip3009PaymentRequirements};

#[cfg_attr(feature = "telemetry", instrument(skip_all, err))]
pub async fn verify_eip3009_payment<P: Eip155MetaTransactionProvider + ChainProviderOps>(
    provider: &P,
    payment_payload: &Eip3009PaymentPayload,
    payment_requirements: &Eip3009PaymentRequirements,
) -> Result<v2::VerifyResponse, X402SchemeFacilitatorError> {
    let accepted = &payment_payload.accepted;
    assert_requirements_match(accepted, payment_requirements)?;
    let (contract, payment, eip712_domain) = assert_valid_payment(
        provider.inner(),
        provider.chain(),
        accepted,
        &payment_payload.payload,
    )
    .await?;

    let payer = verify_payment(provider.inner(), &contract, &payment, &eip712_domain).await?;
    Ok(v2::VerifyResponse::valid(payer.to_string()))
}

#[cfg_attr(feature = "telemetry", instrument(skip_all, err))]
pub async fn settle_eip3009_payment<P>(
    provider: &P,
    payment_payload: &Eip3009PaymentPayload,
    payment_requirements: &Eip3009PaymentRequirements,
) -> Result<v2::SettleResponse, X402SchemeFacilitatorError>
where
    P: Eip155MetaTransactionProvider + ChainProviderOps,
    Eip155ExactError: From<P::Error>,
{
    let accepted = &payment_payload.accepted;
    assert_requirements_match(accepted, payment_requirements)?;
    let (contract, payment, eip712_domain) = assert_valid_payment(
        provider.inner(),
        provider.chain(),
        accepted,
        &payment_payload.payload,
    )
    .await?;

    let tx_hash = settle_payment(provider, &contract, &payment, &eip712_domain).await?;

    Ok(v2::SettleResponse::Success {
        payer: payment.from.to_string(),
        transaction: tx_hash.to_string(),
        network: accepted.network.to_string(),
    })
}

/// Runs all preconditions needed for a successful payment:
/// - Valid scheme, network, and receiver.
/// - Valid time window (validAfter/validBefore).
/// - Correct EIP-712 domain construction.
/// - Sufficient on-chain balance.
/// - Sufficient value in payload.
#[cfg_attr(feature = "telemetry", instrument(skip_all, err))]
pub async fn assert_valid_payment<P: Provider>(
    provider: P,
    chain: &Eip155ChainReference,
    accepted: &Eip3009PaymentRequirements,
    payload: &Eip3009Payload,
) -> Result<(IEIP3009::IEIP3009Instance<P>, ExactEvmPayment, Eip712Domain), Eip155ExactError> {
    let chain_id: ChainId = chain.into();
    let payload_chain_id = &accepted.network;
    if payload_chain_id != &chain_id {
        return Err(PaymentVerificationError::ChainIdMismatch.into());
    }
    let authorization = &payload.authorization;
    if authorization.to != accepted.pay_to {
        return Err(PaymentVerificationError::RecipientMismatch.into());
    }
    let valid_after = authorization.valid_after;
    let valid_before = authorization.valid_before;
    assert_time(valid_after, valid_before)?;
    let asset_address = accepted.asset;
    let contract = IEIP3009::new(asset_address.into(), provider);

    let amount_required = accepted.amount;
    assert_enough_value(&authorization.value, &amount_required)?;

    let extra = Some(PaymentRequirementsExtra {
        name: accepted.extra.name.clone(),
        version: accepted.extra.version.clone(),
    });
    let domain = assert_domain(chain, &contract, &asset_address.into(), &extra).await?;

    assert_enough_balance(&contract, &authorization.from, amount_required).await?;

    let signature = payload.signature.clone();

    let payment = ExactEvmPayment {
        from: authorization.from,
        to: authorization.to,
        value: authorization.value,
        valid_after: authorization.valid_after,
        valid_before: authorization.valid_before,
        nonce: authorization.nonce,
        signature,
    };

    Ok((contract, payment, domain))
}

pub fn assert_requirements_match<T: PartialEq>(
    accepted: &T,
    payment_requirements: &T,
) -> Result<(), PaymentVerificationError> {
    if accepted != payment_requirements {
        Err(PaymentVerificationError::AcceptedRequirementsMismatch)
    } else {
        Ok(())
    }
}