openzeppelin_relayer/models/transaction/request/
mod.rs

1pub mod evm;
2pub mod solana;
3pub mod stellar;
4
5use crate::models::rpc::{
6    SolanaFeeEstimateRequestParams, SolanaPrepareTransactionRequestParams,
7    StellarFeeEstimateRequestParams, StellarPrepareTransactionRequestParams,
8};
9use crate::models::{ApiError, NetworkType, RelayerRepoModel};
10use serde::{Deserialize, Serialize};
11
12pub use evm::EvmTransactionRequest;
13pub use solana::SolanaTransactionRequest;
14pub use stellar::StellarTransactionRequest;
15use utoipa::ToSchema;
16
17#[derive(Serialize, ToSchema)]
18#[serde(untagged)]
19pub enum NetworkTransactionRequest {
20    Evm(EvmTransactionRequest),
21    Solana(SolanaTransactionRequest),
22    Stellar(StellarTransactionRequest),
23}
24
25impl NetworkTransactionRequest {
26    pub fn from_json(
27        network_type: &NetworkType,
28        json: serde_json::Value,
29    ) -> Result<Self, ApiError> {
30        match network_type {
31            NetworkType::Evm => Ok(Self::Evm(
32                serde_json::from_value(json).map_err(|e| ApiError::BadRequest(e.to_string()))?,
33            )),
34            NetworkType::Solana => Ok(Self::Solana(
35                serde_json::from_value(json).map_err(|e| ApiError::BadRequest(e.to_string()))?,
36            )),
37            NetworkType::Stellar => Ok(Self::Stellar(
38                serde_json::from_value(json).map_err(|e| ApiError::BadRequest(e.to_string()))?,
39            )),
40        }
41    }
42
43    pub fn validate(&self, relayer: &RelayerRepoModel) -> Result<(), ApiError> {
44        match self {
45            NetworkTransactionRequest::Evm(request) => request.validate(relayer),
46            NetworkTransactionRequest::Stellar(request) => request.validate(),
47            NetworkTransactionRequest::Solana(request) => request.validate(relayer),
48        }
49    }
50}
51
52/// Network-agnostic fee estimate request parameters for gasless transactions.
53/// Contains network-specific request parameters for fee estimation.
54/// The network type is inferred from the relayer's network configuration.
55#[derive(Debug, Deserialize, Serialize, PartialEq, ToSchema, Clone)]
56#[serde(untagged)]
57#[schema(as = SponsoredTransactionQuoteRequest)]
58pub enum SponsoredTransactionQuoteRequest {
59    /// Solana-specific fee estimate request parameters
60    Solana(SolanaFeeEstimateRequestParams),
61    /// Stellar-specific fee estimate request parameters
62    Stellar(StellarFeeEstimateRequestParams),
63}
64
65impl SponsoredTransactionQuoteRequest {
66    pub fn validate(&self) -> Result<(), ApiError> {
67        match self {
68            SponsoredTransactionQuoteRequest::Stellar(request) => request.validate(),
69            SponsoredTransactionQuoteRequest::Solana(_) => Ok(()),
70        }
71    }
72}
73
74/// Network-agnostic prepare transaction request parameters for gasless transactions.
75/// Contains network-specific request parameters for preparing transactions with fee payments.
76/// The network type is inferred from the relayer's network configuration.
77#[derive(Debug, Deserialize, Serialize, PartialEq, ToSchema, Clone)]
78#[serde(untagged)]
79#[schema(as = SponsoredTransactionBuildRequest)]
80pub enum SponsoredTransactionBuildRequest {
81    /// Solana-specific prepare transaction request parameters
82    Solana(SolanaPrepareTransactionRequestParams),
83    /// Stellar-specific prepare transaction request parameters
84    Stellar(StellarPrepareTransactionRequestParams),
85}
86
87impl SponsoredTransactionBuildRequest {
88    pub fn validate(&self) -> Result<(), ApiError> {
89        match self {
90            SponsoredTransactionBuildRequest::Stellar(request) => request.validate(),
91            SponsoredTransactionBuildRequest::Solana(_) => Ok(()),
92        }
93    }
94}