mod context;
mod metadata;
mod request;
pub use context::{ExecutionContext, ExecutionObservation};
#[cfg(feature = "solana-http")]
pub(crate) use metadata::bounded_entries;
pub use metadata::{
CompiledInnerInstruction, ExecutionBytes, ExecutionOutcome, InnerInstructions, LoadedAddresses,
LogMessage, ReturnData, Reward, RewardKind, TokenBalanceRecord, TransactionMetadata,
TransactionMetadataData,
};
pub use request::{ExecutionRequest, StatusOptions, SubmitOptions, TransactionReadOptions};
use super::{BlockhashLifetime, Commitment, Hash, Signature, SignedTransaction};
use crate::error::{Error, ValidationError};
use serde::{Deserialize, Serialize};
pub(super) fn invalid() -> Error {
ValidationError::InvalidSolanaExecution.into()
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TransactionLookup {
pub signature: Signature,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub transaction: Option<Transaction>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "TransactionFields")]
pub struct Transaction {
body: SignedTransaction,
inclusion_slot: u64,
block_time_unix_seconds: Option<i64>,
#[serde(rename = "transaction_index")]
index_in_block: Option<u32>,
metadata: Option<TransactionMetadata>,
}
impl Transaction {
pub fn new(
body: SignedTransaction,
inclusion_slot: u64,
block_time_unix_seconds: Option<i64>,
transaction_index: Option<u32>,
metadata: Option<TransactionMetadata>,
) -> Result<Self, Error> {
if let Some(value) = &metadata {
value.validate_message(body.message())?;
}
Ok(Self {
body,
inclusion_slot,
block_time_unix_seconds,
index_in_block: transaction_index,
metadata,
})
}
#[must_use]
pub const fn body(&self) -> &SignedTransaction {
&self.body
}
#[must_use]
pub const fn inclusion_slot(&self) -> u64 {
self.inclusion_slot
}
#[must_use]
pub const fn block_time_unix_seconds(&self) -> Option<i64> {
self.block_time_unix_seconds
}
#[must_use]
pub const fn transaction_index(&self) -> Option<u32> {
self.index_in_block
}
#[must_use]
pub const fn metadata(&self) -> Option<&TransactionMetadata> {
self.metadata.as_ref()
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct TransactionFields {
body: SignedTransaction,
inclusion_slot: u64,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
block_time_unix_seconds: Option<i64>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
transaction_index: Option<u32>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
metadata: Option<TransactionMetadata>,
}
impl TryFrom<TransactionFields> for Transaction {
type Error = Error;
fn try_from(f: TransactionFields) -> Result<Self, Error> {
Self::new(
f.body,
f.inclusion_slot,
f.block_time_unix_seconds,
f.transaction_index,
f.metadata,
)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct SignatureStatus {
pub inclusion_slot: u64,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub confirmations: Option<u64>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub confirmation_status: Option<Commitment>,
pub outcome: ExecutionOutcome,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct StatusLookup {
pub signature: Signature,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub status: Option<SignatureStatus>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct LatestBlockhash {
pub lifetime: BlockhashLifetime,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BlockhashValidity {
pub blockhash: Hash,
pub valid: bool,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct BlockHeight {
pub height: u64,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct MessageFee {
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
pub lamports: Option<u64>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "SimulationFields")]
pub struct Simulation {
outcome: ExecutionOutcome,
units_consumed: Option<u64>,
fee_lamports: Option<u64>,
logs: Option<Vec<LogMessage>>,
return_data: Option<ReturnData>,
}
impl Simulation {
pub fn new(
outcome: ExecutionOutcome,
units_consumed: Option<u64>,
fee_lamports: Option<u64>,
logs: Option<Vec<LogMessage>>,
return_data: Option<ReturnData>,
) -> Result<Self, Error> {
metadata::validate_logs(logs.as_deref())?;
Ok(Self {
outcome,
units_consumed,
fee_lamports,
logs,
return_data,
})
}
#[must_use]
pub const fn outcome(&self) -> &ExecutionOutcome {
&self.outcome
}
#[must_use]
pub const fn units_consumed(&self) -> Option<u64> {
self.units_consumed
}
#[must_use]
pub const fn fee_lamports(&self) -> Option<u64> {
self.fee_lamports
}
#[must_use]
pub fn logs(&self) -> Option<&[LogMessage]> {
self.logs.as_deref()
}
#[must_use]
pub const fn return_data(&self) -> Option<&ReturnData> {
self.return_data.as_ref()
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct SimulationFields {
outcome: ExecutionOutcome,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
units_consumed: Option<u64>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
fee_lamports: Option<u64>,
#[serde(deserialize_with = "metadata::optional_logs")]
logs: Option<Vec<LogMessage>>,
#[serde(deserialize_with = "crate::domain::deserialize_optional")]
return_data: Option<ReturnData>,
}
impl TryFrom<SimulationFields> for Simulation {
type Error = Error;
fn try_from(f: SimulationFields) -> Result<Self, Error> {
Self::new(
f.outcome,
f.units_consumed,
f.fee_lamports,
f.logs,
f.return_data,
)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Submission {
pub signature: Signature,
}