use super::super::{
Commitment, Hash, ReadOptions, Signature, UnsignedMessage, UnsignedTransaction,
};
use crate::error::Error;
use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "TransactionOptionsFields")]
pub struct TransactionReadOptions {
commitment: Commitment,
maximum_supported_version: u8,
}
impl TransactionReadOptions {
pub fn new(commitment: Commitment, maximum_supported_version: u8) -> Result<Self, Error> {
if commitment == Commitment::Processed || maximum_supported_version > 1 {
return Err(super::invalid());
}
Ok(Self {
commitment,
maximum_supported_version,
})
}
#[must_use]
pub const fn commitment(self) -> Commitment {
self.commitment
}
#[must_use]
pub const fn maximum_supported_version(self) -> u8 {
self.maximum_supported_version
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct TransactionOptionsFields {
commitment: Commitment,
maximum_supported_version: u8,
}
impl TryFrom<TransactionOptionsFields> for TransactionReadOptions {
type Error = Error;
fn try_from(f: TransactionOptionsFields) -> Result<Self, Error> {
Self::new(f.commitment, f.maximum_supported_version)
}
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StatusOptions {
pub search_transaction_history: bool,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SubmitOptions {
pub preflight_commitment: Commitment,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub minimum_context_slot: Option<u64>,
pub skip_preflight: bool,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "operation", rename_all = "snake_case", deny_unknown_fields)]
pub enum ExecutionRequest {
Transaction {
signature: Signature,
options: TransactionReadOptions,
},
Status {
signature: Signature,
options: StatusOptions,
},
LatestBlockhash {
options: ReadOptions,
},
BlockhashValidity {
blockhash: Hash,
options: ReadOptions,
},
BlockHeight {
commitment: Commitment,
},
MessageFee {
message: UnsignedMessage,
options: ReadOptions,
},
Simulation {
transaction: UnsignedTransaction,
options: ReadOptions,
},
Submission {
signature: Signature,
options: SubmitOptions,
},
}
impl ExecutionRequest {
pub(super) const fn evaluation_options(&self) -> Option<ReadOptions> {
match self {
Self::LatestBlockhash { options }
| Self::BlockhashValidity { options, .. }
| Self::MessageFee { options, .. }
| Self::Simulation { options, .. } => Some(*options),
_ => None,
}
}
pub(super) const fn has_evaluation_slot(&self) -> bool {
matches!(
self,
Self::Status { .. }
| Self::LatestBlockhash { .. }
| Self::BlockhashValidity { .. }
| Self::MessageFee { .. }
| Self::Simulation { .. }
)
}
}