r402-evm 0.20.0

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

//! Batch-settlement contract ABI (official `batch-settlement/abi.ts`).

use alloy_sol_types::sol;

sol! {
    /// `x402BatchSettlement` surface used by deposit / claim / settle / refund.
    #[allow(missing_docs, reason = "sol! generated interface")]
    #[derive(Debug)]
    #[sol(rpc)]
    interface IBatchSettlement {
        struct ChannelConfig {
            address payer;
            address payerAuthorizer;
            address receiver;
            address receiverAuthorizer;
            address token;
            uint40 withdrawDelay;
            bytes32 salt;
        }

        struct Voucher {
            ChannelConfig channel;
            uint128 maxClaimableAmount;
        }

        struct VoucherClaim {
            Voucher voucher;
            bytes signature;
            uint128 totalClaimed;
        }

        function deposit(
            ChannelConfig config,
            uint128 amount,
            address collector,
            bytes collectorData
        ) external;

        function claimWithSignature(
            VoucherClaim[] voucherClaims,
            bytes authorizerSignature
        ) external;

        function settle(address receiver, address token) external;

        function refundWithSignature(
            ChannelConfig config,
            uint128 amount,
            uint256 nonce,
            bytes receiverAuthorizerSignature
        ) external;

        function multicall(bytes[] data) external returns (bytes[] results);

        function channels(bytes32 channelId) external view returns (uint128 balance, uint128 totalClaimed);

        function pendingWithdrawals(bytes32 channelId) external view returns (uint128 amount, uint40 initiatedAt);

        function refundNonce(bytes32 channelId) external view returns (uint256);

        function receivers(address receiver, address token)
            external
            view
            returns (uint128 totalClaimed, uint128 totalSettled);

        event Settled(
            address indexed receiver,
            address indexed token,
            address indexed sender,
            uint128 amount
        );
    }
}

#[cfg(test)]
mod tests {
    use alloy_primitives::keccak256;
    use alloy_sol_types::SolCall;

    use super::IBatchSettlement;

    fn sel(sig: &str) -> [u8; 4] {
        let hash = keccak256(sig.as_bytes());
        [hash[0], hash[1], hash[2], hash[3]]
    }

    #[test]
    fn selectors_match_canonical_signatures() {
        assert_eq!(
            IBatchSettlement::depositCall::SELECTOR,
            sel(
                "deposit((address,address,address,address,address,uint40,bytes32),uint128,address,bytes)"
            )
        );
        assert_eq!(
            IBatchSettlement::claimWithSignatureCall::SELECTOR,
            sel(
                "claimWithSignature((((address,address,address,address,address,uint40,bytes32),uint128),bytes,uint128)[],bytes)"
            )
        );
        assert_eq!(
            IBatchSettlement::settleCall::SELECTOR,
            sel("settle(address,address)")
        );
        assert_eq!(
            IBatchSettlement::refundWithSignatureCall::SELECTOR,
            sel(
                "refundWithSignature((address,address,address,address,address,uint40,bytes32),uint128,uint256,bytes)"
            )
        );
        assert_eq!(
            IBatchSettlement::multicallCall::SELECTOR,
            sel("multicall(bytes[])")
        );
    }
}