2021-07-09 13:06:06 -07:00
|
|
|
use {
|
|
|
|
serde::{Deserialize, Serialize},
|
|
|
|
solana_account_decoder::{
|
|
|
|
parse_token::{real_number_string_trimmed, UiTokenAmount},
|
|
|
|
StringAmount,
|
|
|
|
},
|
2022-01-13 23:24:41 -08:00
|
|
|
solana_sdk::{
|
|
|
|
deserialize_utils::default_on_eof, message::v0::LoadedAddresses, transaction::Result,
|
2022-03-22 15:17:05 -07:00
|
|
|
transaction_context::TransactionReturnData,
|
2022-01-13 23:24:41 -08:00
|
|
|
},
|
2021-07-09 13:06:06 -07:00
|
|
|
solana_transaction_status::{
|
|
|
|
InnerInstructions, Reward, RewardType, TransactionStatusMeta, TransactionTokenBalance,
|
|
|
|
},
|
|
|
|
std::str::FromStr,
|
2021-03-05 08:05:35 -08:00
|
|
|
};
|
2020-10-15 17:04:10 -07:00
|
|
|
|
|
|
|
pub mod convert;
|
|
|
|
|
|
|
|
pub type StoredExtendedRewards = Vec<StoredExtendedReward>;
|
|
|
|
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
|
|
pub struct StoredExtendedReward {
|
|
|
|
pubkey: String,
|
|
|
|
lamports: i64,
|
|
|
|
#[serde(deserialize_with = "default_on_eof")]
|
|
|
|
post_balance: u64,
|
|
|
|
#[serde(deserialize_with = "default_on_eof")]
|
|
|
|
reward_type: Option<RewardType>,
|
2021-07-10 23:18:42 -07:00
|
|
|
#[serde(deserialize_with = "default_on_eof")]
|
|
|
|
commission: Option<u8>,
|
2020-10-15 17:04:10 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
impl From<StoredExtendedReward> for Reward {
|
|
|
|
fn from(value: StoredExtendedReward) -> Self {
|
|
|
|
let StoredExtendedReward {
|
|
|
|
pubkey,
|
|
|
|
lamports,
|
|
|
|
post_balance,
|
|
|
|
reward_type,
|
2021-07-10 23:18:42 -07:00
|
|
|
commission,
|
2020-10-15 17:04:10 -07:00
|
|
|
} = value;
|
|
|
|
Self {
|
|
|
|
pubkey,
|
|
|
|
lamports,
|
|
|
|
post_balance,
|
|
|
|
reward_type,
|
2021-07-10 23:18:42 -07:00
|
|
|
commission,
|
2020-10-15 17:04:10 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<Reward> for StoredExtendedReward {
|
|
|
|
fn from(value: Reward) -> Self {
|
|
|
|
let Reward {
|
|
|
|
pubkey,
|
|
|
|
lamports,
|
|
|
|
post_balance,
|
|
|
|
reward_type,
|
2021-07-10 23:18:42 -07:00
|
|
|
commission,
|
2020-10-15 17:04:10 -07:00
|
|
|
} = value;
|
|
|
|
Self {
|
|
|
|
pubkey,
|
|
|
|
lamports,
|
|
|
|
post_balance,
|
|
|
|
reward_type,
|
2021-07-10 23:18:42 -07:00
|
|
|
commission,
|
2020-10-15 17:04:10 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2021-03-05 08:05:35 -08:00
|
|
|
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
|
|
pub struct StoredTokenAmount {
|
|
|
|
pub ui_amount: f64,
|
|
|
|
pub decimals: u8,
|
|
|
|
pub amount: StringAmount,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<StoredTokenAmount> for UiTokenAmount {
|
|
|
|
fn from(value: StoredTokenAmount) -> Self {
|
|
|
|
let StoredTokenAmount {
|
|
|
|
ui_amount,
|
|
|
|
decimals,
|
|
|
|
amount,
|
|
|
|
} = value;
|
|
|
|
let ui_amount_string =
|
|
|
|
real_number_string_trimmed(u64::from_str(&amount).unwrap_or(0), decimals);
|
|
|
|
Self {
|
|
|
|
ui_amount: Some(ui_amount),
|
|
|
|
decimals,
|
|
|
|
amount,
|
|
|
|
ui_amount_string,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<UiTokenAmount> for StoredTokenAmount {
|
|
|
|
fn from(value: UiTokenAmount) -> Self {
|
|
|
|
let UiTokenAmount {
|
|
|
|
ui_amount,
|
|
|
|
decimals,
|
|
|
|
amount,
|
|
|
|
..
|
|
|
|
} = value;
|
|
|
|
Self {
|
|
|
|
ui_amount: ui_amount.unwrap_or(0.0),
|
|
|
|
decimals,
|
|
|
|
amount,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
|
|
pub struct StoredTransactionTokenBalance {
|
|
|
|
pub account_index: u8,
|
|
|
|
pub mint: String,
|
|
|
|
pub ui_token_amount: StoredTokenAmount,
|
2021-10-13 20:46:52 -07:00
|
|
|
#[serde(deserialize_with = "default_on_eof")]
|
|
|
|
pub owner: String,
|
2022-04-19 21:01:22 -07:00
|
|
|
#[serde(deserialize_with = "default_on_eof")]
|
|
|
|
pub program_id: String,
|
2021-03-05 08:05:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
impl From<StoredTransactionTokenBalance> for TransactionTokenBalance {
|
|
|
|
fn from(value: StoredTransactionTokenBalance) -> Self {
|
|
|
|
let StoredTransactionTokenBalance {
|
|
|
|
account_index,
|
|
|
|
mint,
|
|
|
|
ui_token_amount,
|
2021-10-13 20:46:52 -07:00
|
|
|
owner,
|
2022-04-19 21:01:22 -07:00
|
|
|
program_id,
|
2021-03-05 08:05:35 -08:00
|
|
|
} = value;
|
|
|
|
Self {
|
|
|
|
account_index,
|
|
|
|
mint,
|
|
|
|
ui_token_amount: ui_token_amount.into(),
|
2021-10-13 20:46:52 -07:00
|
|
|
owner,
|
2022-04-19 21:01:22 -07:00
|
|
|
program_id,
|
2021-03-05 08:05:35 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
impl From<TransactionTokenBalance> for StoredTransactionTokenBalance {
|
|
|
|
fn from(value: TransactionTokenBalance) -> Self {
|
|
|
|
let TransactionTokenBalance {
|
|
|
|
account_index,
|
|
|
|
mint,
|
|
|
|
ui_token_amount,
|
2021-10-13 20:46:52 -07:00
|
|
|
owner,
|
2022-04-19 21:01:22 -07:00
|
|
|
program_id,
|
2021-03-05 08:05:35 -08:00
|
|
|
} = value;
|
|
|
|
Self {
|
|
|
|
account_index,
|
|
|
|
mint,
|
|
|
|
ui_token_amount: ui_token_amount.into(),
|
2021-10-13 20:46:52 -07:00
|
|
|
owner,
|
2022-04-19 21:01:22 -07:00
|
|
|
program_id,
|
2021-03-05 08:05:35 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Serialize, Deserialize)]
|
|
|
|
pub struct StoredTransactionStatusMeta {
|
|
|
|
pub status: Result<()>,
|
|
|
|
pub fee: u64,
|
|
|
|
pub pre_balances: Vec<u64>,
|
|
|
|
pub post_balances: Vec<u64>,
|
|
|
|
#[serde(deserialize_with = "default_on_eof")]
|
|
|
|
pub inner_instructions: Option<Vec<InnerInstructions>>,
|
|
|
|
#[serde(deserialize_with = "default_on_eof")]
|
|
|
|
pub log_messages: Option<Vec<String>>,
|
|
|
|
#[serde(deserialize_with = "default_on_eof")]
|
|
|
|
pub pre_token_balances: Option<Vec<StoredTransactionTokenBalance>>,
|
|
|
|
#[serde(deserialize_with = "default_on_eof")]
|
|
|
|
pub post_token_balances: Option<Vec<StoredTransactionTokenBalance>>,
|
2021-05-26 14:43:15 -07:00
|
|
|
#[serde(deserialize_with = "default_on_eof")]
|
|
|
|
pub rewards: Option<Vec<StoredExtendedReward>>,
|
2022-03-22 15:17:05 -07:00
|
|
|
#[serde(deserialize_with = "default_on_eof")]
|
|
|
|
pub return_data: Option<TransactionReturnData>,
|
2022-08-06 10:14:31 -07:00
|
|
|
#[serde(deserialize_with = "default_on_eof")]
|
|
|
|
pub compute_units_consumed: Option<u64>,
|
2021-03-05 08:05:35 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
impl From<StoredTransactionStatusMeta> for TransactionStatusMeta {
|
|
|
|
fn from(value: StoredTransactionStatusMeta) -> Self {
|
|
|
|
let StoredTransactionStatusMeta {
|
|
|
|
status,
|
|
|
|
fee,
|
|
|
|
pre_balances,
|
|
|
|
post_balances,
|
|
|
|
inner_instructions,
|
|
|
|
log_messages,
|
|
|
|
pre_token_balances,
|
|
|
|
post_token_balances,
|
2021-05-26 14:43:15 -07:00
|
|
|
rewards,
|
2022-03-22 15:17:05 -07:00
|
|
|
return_data,
|
2022-08-06 10:14:31 -07:00
|
|
|
compute_units_consumed,
|
2021-03-05 08:05:35 -08:00
|
|
|
} = value;
|
|
|
|
Self {
|
|
|
|
status,
|
|
|
|
fee,
|
|
|
|
pre_balances,
|
|
|
|
post_balances,
|
|
|
|
inner_instructions,
|
|
|
|
log_messages,
|
|
|
|
pre_token_balances: pre_token_balances
|
|
|
|
.map(|balances| balances.into_iter().map(|balance| balance.into()).collect()),
|
|
|
|
post_token_balances: post_token_balances
|
|
|
|
.map(|balances| balances.into_iter().map(|balance| balance.into()).collect()),
|
2021-05-26 14:43:15 -07:00
|
|
|
rewards: rewards
|
|
|
|
.map(|rewards| rewards.into_iter().map(|reward| reward.into()).collect()),
|
2022-01-13 23:24:41 -08:00
|
|
|
loaded_addresses: LoadedAddresses::default(),
|
2022-03-22 15:17:05 -07:00
|
|
|
return_data,
|
2022-08-06 10:14:31 -07:00
|
|
|
compute_units_consumed,
|
2021-03-05 08:05:35 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2022-01-13 23:24:41 -08:00
|
|
|
impl TryFrom<TransactionStatusMeta> for StoredTransactionStatusMeta {
|
|
|
|
type Error = bincode::Error;
|
|
|
|
fn try_from(value: TransactionStatusMeta) -> std::result::Result<Self, Self::Error> {
|
2021-03-05 08:05:35 -08:00
|
|
|
let TransactionStatusMeta {
|
|
|
|
status,
|
|
|
|
fee,
|
|
|
|
pre_balances,
|
|
|
|
post_balances,
|
|
|
|
inner_instructions,
|
|
|
|
log_messages,
|
|
|
|
pre_token_balances,
|
|
|
|
post_token_balances,
|
2021-05-26 14:43:15 -07:00
|
|
|
rewards,
|
2022-01-13 23:24:41 -08:00
|
|
|
loaded_addresses,
|
2022-03-22 15:17:05 -07:00
|
|
|
return_data,
|
2022-08-06 10:14:31 -07:00
|
|
|
compute_units_consumed,
|
2021-03-05 08:05:35 -08:00
|
|
|
} = value;
|
2022-01-13 23:24:41 -08:00
|
|
|
|
|
|
|
if !loaded_addresses.is_empty() {
|
|
|
|
// Deprecated bincode serialized status metadata doesn't support
|
|
|
|
// loaded addresses.
|
|
|
|
return Err(
|
|
|
|
bincode::ErrorKind::Custom("Bincode serialization is deprecated".into()).into(),
|
|
|
|
);
|
|
|
|
}
|
|
|
|
|
|
|
|
Ok(Self {
|
2021-03-05 08:05:35 -08:00
|
|
|
status,
|
|
|
|
fee,
|
|
|
|
pre_balances,
|
|
|
|
post_balances,
|
|
|
|
inner_instructions,
|
|
|
|
log_messages,
|
|
|
|
pre_token_balances: pre_token_balances
|
|
|
|
.map(|balances| balances.into_iter().map(|balance| balance.into()).collect()),
|
|
|
|
post_token_balances: post_token_balances
|
|
|
|
.map(|balances| balances.into_iter().map(|balance| balance.into()).collect()),
|
2021-05-26 14:43:15 -07:00
|
|
|
rewards: rewards
|
|
|
|
.map(|rewards| rewards.into_iter().map(|reward| reward.into()).collect()),
|
2022-03-22 15:17:05 -07:00
|
|
|
return_data,
|
2022-08-06 10:14:31 -07:00
|
|
|
compute_units_consumed,
|
2022-01-13 23:24:41 -08:00
|
|
|
})
|
2021-03-05 08:05:35 -08:00
|
|
|
}
|
|
|
|
}
|