use super::{Cursor, HistoryRequest, MetadataValue, ParseRequest, SortDirection, SourceText};
use crate::{
domain::solana::{ExecutionBytes, Pubkey, Signature},
error::Error,
};
use serde::{Deserialize, Serialize};
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NativeTransfer {
pub from_user_account: Option<Pubkey>,
pub to_user_account: Option<Pubkey>,
pub amount: u64,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TokenTransfer {
pub from_user_account: Option<Pubkey>,
pub to_user_account: Option<Pubkey>,
pub from_token_account: Option<Pubkey>,
pub to_token_account: Option<Pubkey>,
pub raw_token_amount: u64,
pub decimals: u8,
pub mint: Pubkey,
pub token_standard: Option<SourceText>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct Summary {
pub category: SourceText,
pub description: SourceText,
pub parsed_data: Option<MetadataValue>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct NamedAccount {
pub name: SourceText,
pub pubkey: Pubkey,
pub is_signer: bool,
pub is_writable: bool,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DecodedInstruction {
pub args: MetadataValue,
#[serde(deserialize_with = "super::bounded::list")]
pub accounts: Vec<NamedAccount>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ParsedInstruction {
pub instruction_index: u32,
pub inner_instruction_index: Option<u32>,
pub stack_height: Option<u32>,
pub program_id: Pubkey,
#[serde(deserialize_with = "super::bounded::list")]
pub raw_accounts: Vec<Pubkey>,
pub raw_data: ExecutionBytes,
pub summary: Option<Summary>,
pub program_name: Option<SourceText>,
pub instruction_name: Option<SourceText>,
pub decoded: Option<DecodedInstruction>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct DecodedError {
pub instruction_index: u32,
pub program_id: Pubkey,
pub program_name: SourceText,
pub code: u32,
pub name: SourceText,
pub message: Option<SourceText>,
}
#[derive(Clone, Copy, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum TransactionStatus {
Succeeded,
Failed,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct ParsedTransactionData {
pub slot: u64,
pub block_time: Option<i64>,
pub fee: u64,
pub fee_payer: Option<Pubkey>,
pub transaction_status: TransactionStatus,
pub error: Option<MetadataValue>,
pub decoded_error: Option<DecodedError>,
#[serde(deserialize_with = "super::bounded::list")]
pub native_transfers: Vec<NativeTransfer>,
#[serde(deserialize_with = "super::bounded::list")]
pub token_transfers: Vec<TokenTransfer>,
pub summary: Option<Summary>,
#[serde(deserialize_with = "super::bounded::list")]
pub instructions: Vec<ParsedInstruction>,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "ParsedTransactionData", into = "ParsedTransactionData")]
pub struct ParsedTransaction(ParsedTransactionData);
impl ParsedTransaction {
pub fn new(data: ParsedTransactionData) -> Result<Self, Error> {
let mut instruction_keys = std::collections::BTreeSet::new();
if data.native_transfers.len() > 4096
|| data.token_transfers.len() > 4096
|| data.instructions.len() > 4096
|| data.transaction_status == TransactionStatus::Succeeded
&& (data.error.is_some() || data.decoded_error.is_some())
|| data
.decoded_error
.as_ref()
.is_some_and(|e| e.instruction_index >= 4096)
|| data.instructions.iter().any(|i| {
i.instruction_index >= 4096
|| i.inner_instruction_index.is_some_and(|v| v >= 4096)
|| i.stack_height.is_some_and(|v| v == 0 || v > 64)
|| i.raw_accounts.len() > 256
|| i.decoded.as_ref().is_some_and(|d| d.accounts.len() > 256)
|| !instruction_keys.insert((i.instruction_index, i.inner_instruction_index))
})
{
return Err(super::bounded::invalid_transaction());
}
Ok(Self(data))
}
#[must_use]
pub const fn data(&self) -> &ParsedTransactionData {
&self.0
}
}
impl TryFrom<ParsedTransactionData> for ParsedTransaction {
type Error = Error;
fn try_from(d: ParsedTransactionData) -> Result<Self, Error> {
Self::new(d)
}
}
impl From<ParsedTransaction> for ParsedTransactionData {
fn from(v: ParsedTransaction) -> Self {
v.0
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(tag = "parser_status", rename_all = "snake_case", deny_unknown_fields)]
pub enum ParseOutcome {
Ok {
parsed: Box<ParsedTransaction>,
},
Error {
code: SourceText,
},
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(deny_unknown_fields)]
pub struct TransactionResult {
pub signature: Signature,
pub outcome: ParseOutcome,
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "ParsedBatchFields")]
pub struct ParsedBatch {
request: ParseRequest,
results: Vec<TransactionResult>,
}
fn valid_result(result: &TransactionResult) -> bool {
match &result.outcome {
ParseOutcome::Ok { .. } => true,
ParseOutcome::Error { code } => {
!code.as_str().is_empty()
&& code.as_str().len() <= 256
&& !code.as_str().chars().any(char::is_control)
}
}
}
impl ParsedBatch {
pub fn new(request: ParseRequest, results: Vec<TransactionResult>) -> Result<Self, Error> {
if results.len() != request.signatures().len()
|| results
.iter()
.zip(request.signatures())
.any(|(r, s)| r.signature != *s || !valid_result(r))
{
return Err(super::bounded::invalid_transaction());
}
Ok(Self { request, results })
}
#[must_use]
pub const fn request(&self) -> &ParseRequest {
&self.request
}
#[must_use]
pub fn results(&self) -> &[TransactionResult] {
&self.results
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct ParsedBatchFields {
request: ParseRequest,
#[serde(deserialize_with = "super::bounded::list")]
results: Vec<TransactionResult>,
}
impl TryFrom<ParsedBatchFields> for ParsedBatch {
type Error = Error;
fn try_from(f: ParsedBatchFields) -> Result<Self, Error> {
Self::new(f.request, f.results)
}
}
#[derive(Clone, Debug, Eq, PartialEq, Serialize, Deserialize)]
#[serde(try_from = "HistoryPageFields")]
pub struct HistoryPage {
request: HistoryRequest,
results: Vec<TransactionResult>,
pagination_token: Option<Cursor>,
}
impl HistoryPage {
pub fn new(
request: HistoryRequest,
results: Vec<TransactionResult>,
pagination_token: Option<Cursor>,
) -> Result<Self, Error> {
let mut signatures = std::collections::BTreeSet::new();
let mut previous = None;
if results.len() > usize::from(request.limit())
|| pagination_token
.as_ref()
.zip(request.pagination_token())
.is_some_and(|(a, b)| a == b)
{
return Err(super::bounded::invalid_transaction());
}
for result in &results {
if !valid_result(result)
|| !signatures.insert(result.signature)
|| request.signatures().contains(&Some(result.signature))
{
return Err(super::bounded::invalid_transaction());
}
if let ParseOutcome::Ok { parsed } = &result.outcome {
let data = parsed.data();
if request.slot().is_some_and(|b| !b.contains(data.slot))
|| request
.time()
.zip(data.block_time)
.is_some_and(|(b, t)| u64::try_from(t).map_or(true, |t| !b.contains(t)))
|| previous.is_some_and(|p| match request.direction() {
SortDirection::Asc => p > data.slot,
SortDirection::Desc => p < data.slot,
})
{
return Err(super::bounded::invalid_transaction());
}
previous = Some(data.slot);
}
}
Ok(Self {
request,
results,
pagination_token,
})
}
#[must_use]
pub const fn request(&self) -> &HistoryRequest {
&self.request
}
#[must_use]
pub fn results(&self) -> &[TransactionResult] {
&self.results
}
#[must_use]
pub const fn pagination_token(&self) -> Option<&Cursor> {
self.pagination_token.as_ref()
}
}
#[derive(Deserialize)]
#[serde(deny_unknown_fields)]
struct HistoryPageFields {
request: HistoryRequest,
#[serde(deserialize_with = "super::bounded::list")]
results: Vec<TransactionResult>,
pagination_token: Option<Cursor>,
}
impl TryFrom<HistoryPageFields> for HistoryPage {
type Error = Error;
fn try_from(f: HistoryPageFields) -> Result<Self, Error> {
Self::new(f.request, f.results, f.pagination_token)
}
}