1use crate::client::{AuthenticatedOpenPaymentsClient, BaseClient};
2use crate::types::{
3 AccessTokenResponse, ContinueResponse, GrantRequest, GrantResponse, IncomingPayment,
4 IncomingPaymentRequest, JsonWebKeySet, ListIncomingPaymentsResponse,
5 ListOutgoingPaymentsResponse, OutgoingPayment, OutgoingPaymentRequest, PublicIncomingPayment,
6 Quote, QuoteRequest, WalletAddress,
7};
8use crate::{
9 grant::{cancel_grant, continue_grant, request_grant},
10 payments::{
11 complete_incoming_payment, create_incoming_payment, create_outgoing_payment,
12 get_incoming_payment, get_outgoing_payment, get_public_incoming_payment,
13 list_incoming_payments, list_outgoing_payments,
14 },
15 quotes::{create_quote, get_quote},
16 token::{revoke_access_token, rotate_access_token},
17 wallet_address::{get_keys, get_wallet_address},
18 Result,
19};
20pub mod authenticated {
21 use super::*;
22
23 pub struct QuoteResource<'a> {
24 client: &'a AuthenticatedOpenPaymentsClient,
25 }
26
27 impl<'a> QuoteResource<'a> {
28 pub(crate) fn new(client: &'a AuthenticatedOpenPaymentsClient) -> Self {
29 Self { client }
30 }
31
32 pub async fn create(
33 &self,
34 resource_server_url: &str,
35 req_body: &QuoteRequest,
36 access_token: Option<&str>,
37 ) -> Result<Quote> {
38 create_quote(self.client, resource_server_url, req_body, access_token).await
39 }
40
41 pub async fn get(&self, quote_url: &str, access_token: Option<&str>) -> Result<Quote> {
42 get_quote(self.client, quote_url, access_token).await
43 }
44 }
45 pub struct IncomingPaymentResource<'a> {
46 client: &'a AuthenticatedOpenPaymentsClient,
47 }
48
49 impl<'a> IncomingPaymentResource<'a> {
50 pub(crate) fn new(client: &'a AuthenticatedOpenPaymentsClient) -> Self {
51 Self { client }
52 }
53
54 pub async fn create(
55 &self,
56 resource_server_url: &str,
57 req_body: &IncomingPaymentRequest,
58 access_token: Option<&str>,
59 ) -> Result<IncomingPayment> {
60 create_incoming_payment(self.client, resource_server_url, req_body, access_token).await
61 }
62
63 pub async fn get(
64 &self,
65 payment_url: &str,
66 access_token: Option<&str>,
67 ) -> Result<IncomingPayment> {
68 get_incoming_payment(self.client, payment_url, access_token).await
69 }
70
71 pub async fn complete(
72 &self,
73 payment_url: &str,
74 access_token: Option<&str>,
75 ) -> Result<IncomingPayment> {
76 complete_incoming_payment(self.client, payment_url, access_token).await
77 }
78
79 pub async fn list(
80 &self,
81 resource_server_url: &str,
82 wallet_address: &str,
83 cursor: Option<&str>,
84 first: Option<u32>,
85 last: Option<u32>,
86 access_token: Option<&str>,
87 ) -> Result<ListIncomingPaymentsResponse> {
88 list_incoming_payments(
89 self.client,
90 resource_server_url,
91 wallet_address,
92 cursor,
93 first,
94 last,
95 access_token,
96 )
97 .await
98 }
99 }
100
101 pub struct OutgoingPaymentResource<'a> {
102 client: &'a AuthenticatedOpenPaymentsClient,
103 }
104
105 impl<'a> OutgoingPaymentResource<'a> {
106 pub(crate) fn new(client: &'a AuthenticatedOpenPaymentsClient) -> Self {
107 Self { client }
108 }
109
110 pub async fn create(
111 &self,
112 resource_server_url: &str,
113 req_body: &OutgoingPaymentRequest,
114 access_token: Option<&str>,
115 ) -> Result<OutgoingPayment> {
116 create_outgoing_payment(self.client, resource_server_url, req_body, access_token).await
117 }
118
119 pub async fn list(
120 &self,
121 resource_server_url: &str,
122 wallet_address: &str,
123 cursor: Option<&str>,
124 first: Option<u32>,
125 last: Option<u32>,
126 access_token: Option<&str>,
127 ) -> Result<ListOutgoingPaymentsResponse> {
128 list_outgoing_payments(
129 self.client,
130 resource_server_url,
131 wallet_address,
132 cursor,
133 first,
134 last,
135 access_token,
136 )
137 .await
138 }
139
140 pub async fn get(
141 &self,
142 payment_url: &str,
143 access_token: Option<&str>,
144 ) -> Result<OutgoingPayment> {
145 get_outgoing_payment(self.client, payment_url, access_token).await
146 }
147 }
148
149 pub struct Grant<'a> {
150 client: &'a AuthenticatedOpenPaymentsClient,
151 }
152
153 impl<'a> Grant<'a> {
154 pub(crate) fn new(client: &'a AuthenticatedOpenPaymentsClient) -> Self {
155 Self { client }
156 }
157
158 pub async fn request(&self, auth_url: &str, grant: &GrantRequest) -> Result<GrantResponse> {
159 request_grant(self.client, auth_url, grant).await
160 }
161
162 pub async fn continue_grant(
163 &self,
164 continue_uri: &str,
165 interact_ref: &str,
166 access_token: Option<&str>,
167 ) -> Result<ContinueResponse> {
168 continue_grant(self.client, continue_uri, interact_ref, access_token).await
169 }
170
171 pub async fn cancel(&self, continue_uri: &str, access_token: Option<&str>) -> Result<()> {
172 cancel_grant(self.client, continue_uri, access_token).await
173 }
174 }
175
176 pub struct Token<'a> {
177 client: &'a AuthenticatedOpenPaymentsClient,
178 }
179
180 impl<'a> Token<'a> {
181 pub(crate) fn new(client: &'a AuthenticatedOpenPaymentsClient) -> Self {
182 Self { client }
183 }
184
185 pub async fn rotate(
186 &self,
187 auth_url: &str,
188 access_token: Option<&str>,
189 ) -> Result<AccessTokenResponse> {
190 rotate_access_token(self.client, auth_url, access_token).await
191 }
192
193 pub async fn revoke(&self, auth_url: &str, access_token: Option<&str>) -> Result<()> {
194 revoke_access_token(self.client, auth_url, access_token).await
195 }
196 }
197}
198
199pub mod unauthenticated {
200 use super::*;
201
202 pub struct WalletAddressResource<'a, C: BaseClient> {
203 client: &'a C,
204 }
205
206 impl<'a, C: BaseClient> WalletAddressResource<'a, C> {
207 pub(crate) fn new(client: &'a C) -> Self {
208 Self { client }
209 }
210
211 pub async fn get(&self, wallet_address_url: &str) -> Result<WalletAddress> {
212 get_wallet_address(self.client.http_client(), wallet_address_url).await
213 }
214
215 pub async fn get_keys(&self, wallet: &WalletAddress) -> Result<JsonWebKeySet> {
216 get_keys(self.client.http_client(), wallet).await
217 }
218
219 pub async fn get_did_document(&self, _wallet: &WalletAddress) -> Result<()> {
220 unimplemented!()
221 }
222 }
223
224 pub struct IncomingPaymentResource<'a, C: BaseClient> {
225 client: &'a C,
226 }
227
228 impl<'a, C: BaseClient> IncomingPaymentResource<'a, C> {
229 pub(crate) fn new(client: &'a C) -> Self {
230 Self { client }
231 }
232
233 pub async fn get(&self, payment_url: &str) -> Result<PublicIncomingPayment> {
234 get_public_incoming_payment(self.client, payment_url).await
235 }
236 }
237}
238
239pub trait AuthenticatedResources {
240 fn quotes(&self) -> authenticated::QuoteResource;
241 fn incoming_payments(&self) -> authenticated::IncomingPaymentResource;
242 fn outgoing_payments(&self) -> authenticated::OutgoingPaymentResource;
243 fn grant(&self) -> authenticated::Grant;
244 fn token(&self) -> authenticated::Token;
245}
246
247pub trait UnauthenticatedResources: BaseClient + Sized {
249 fn wallet_address(&self) -> unauthenticated::WalletAddressResource<Self>;
250 fn public_incoming_payments(&self) -> unauthenticated::IncomingPaymentResource<Self>;
251}
252
253impl AuthenticatedResources for AuthenticatedOpenPaymentsClient {
254 fn quotes(&self) -> authenticated::QuoteResource {
255 authenticated::QuoteResource::new(self)
256 }
257
258 fn incoming_payments(&self) -> authenticated::IncomingPaymentResource {
259 authenticated::IncomingPaymentResource::new(self)
260 }
261
262 fn outgoing_payments(&self) -> authenticated::OutgoingPaymentResource {
263 authenticated::OutgoingPaymentResource::new(self)
264 }
265
266 fn grant(&self) -> authenticated::Grant {
267 authenticated::Grant::new(self)
268 }
269
270 fn token(&self) -> authenticated::Token {
271 authenticated::Token::new(self)
272 }
273}
274
275impl<C: BaseClient> UnauthenticatedResources for C {
276 fn wallet_address(&self) -> unauthenticated::WalletAddressResource<Self> {
277 unauthenticated::WalletAddressResource::new(self)
278 }
279
280 fn public_incoming_payments(&self) -> unauthenticated::IncomingPaymentResource<Self> {
281 unauthenticated::IncomingPaymentResource::new(self)
282 }
283}