2020-03-26 13:29:30 -07:00
|
|
|
#[macro_use]
|
2020-06-19 15:15:13 -07:00
|
|
|
extern crate lazy_static;
|
|
|
|
#[macro_use]
|
2020-03-26 13:29:30 -07:00
|
|
|
extern crate serde_derive;
|
|
|
|
|
2020-06-19 15:15:13 -07:00
|
|
|
pub mod parse_accounts;
|
|
|
|
pub mod parse_instruction;
|
2020-07-31 12:26:09 -07:00
|
|
|
pub mod parse_token;
|
2020-06-19 15:15:13 -07:00
|
|
|
|
2020-08-04 23:58:58 -07:00
|
|
|
use crate::{
|
|
|
|
parse_accounts::{parse_accounts, ParsedAccount},
|
|
|
|
parse_instruction::{parse, ParsedInstruction},
|
|
|
|
};
|
2020-03-26 13:29:30 -07:00
|
|
|
use solana_sdk::{
|
2020-07-09 21:47:29 -07:00
|
|
|
clock::{Slot, UnixTimestamp},
|
2020-04-06 03:04:54 -07:00
|
|
|
commitment_config::CommitmentConfig,
|
2020-06-19 15:15:13 -07:00
|
|
|
instruction::CompiledInstruction,
|
2020-03-26 13:29:30 -07:00
|
|
|
message::MessageHeader,
|
2020-08-03 13:27:15 -07:00
|
|
|
pubkey::Pubkey,
|
2020-07-27 11:42:49 -07:00
|
|
|
signature::Signature,
|
2020-04-04 16:13:26 -07:00
|
|
|
transaction::{Result, Transaction, TransactionError},
|
2020-03-26 13:29:30 -07:00
|
|
|
};
|
|
|
|
|
2020-07-01 13:06:40 -07:00
|
|
|
/// A duplicate representation of an Instruction for pretty JSON serialization
|
2020-06-19 15:15:13 -07:00
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase", untagged)]
|
2020-07-01 13:06:40 -07:00
|
|
|
pub enum UiInstruction {
|
|
|
|
Compiled(UiCompiledInstruction),
|
2020-08-04 23:58:58 -07:00
|
|
|
Parsed(UiParsedInstruction),
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase", untagged)]
|
|
|
|
pub enum UiParsedInstruction {
|
|
|
|
Parsed(ParsedInstruction),
|
|
|
|
PartiallyDecoded(UiPartiallyDecodedInstruction),
|
2020-06-19 15:15:13 -07:00
|
|
|
}
|
|
|
|
|
2020-06-30 21:55:11 -07:00
|
|
|
/// A duplicate representation of a CompiledInstruction for pretty JSON serialization
|
2020-03-26 13:29:30 -07:00
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
2020-07-01 13:06:40 -07:00
|
|
|
pub struct UiCompiledInstruction {
|
2020-03-26 13:29:30 -07:00
|
|
|
pub program_id_index: u8,
|
|
|
|
pub accounts: Vec<u8>,
|
|
|
|
pub data: String,
|
|
|
|
}
|
|
|
|
|
2020-07-01 13:06:40 -07:00
|
|
|
impl From<&CompiledInstruction> for UiCompiledInstruction {
|
2020-06-19 15:15:13 -07:00
|
|
|
fn from(instruction: &CompiledInstruction) -> Self {
|
|
|
|
Self {
|
|
|
|
program_id_index: instruction.program_id_index,
|
|
|
|
accounts: instruction.accounts.clone(),
|
|
|
|
data: bs58::encode(instruction.data.clone()).into_string(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-08-03 13:27:15 -07:00
|
|
|
/// A partially decoded CompiledInstruction that includes explicit account addresses
|
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct UiPartiallyDecodedInstruction {
|
|
|
|
pub program_id: String,
|
|
|
|
pub accounts: Vec<String>,
|
|
|
|
pub data: String,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl UiPartiallyDecodedInstruction {
|
|
|
|
fn from(instruction: &CompiledInstruction, account_keys: &[Pubkey]) -> Self {
|
|
|
|
Self {
|
|
|
|
program_id: account_keys[instruction.program_id_index as usize].to_string(),
|
|
|
|
accounts: instruction
|
|
|
|
.accounts
|
|
|
|
.iter()
|
|
|
|
.map(|&i| account_keys[i as usize].to_string())
|
|
|
|
.collect(),
|
|
|
|
data: bs58::encode(instruction.data.clone()).into_string(),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-26 13:29:30 -07:00
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct TransactionStatusMeta {
|
|
|
|
pub status: Result<()>,
|
|
|
|
pub fee: u64,
|
|
|
|
pub pre_balances: Vec<u64>,
|
|
|
|
pub post_balances: Vec<u64>,
|
|
|
|
}
|
|
|
|
|
2020-04-04 20:24:06 -07:00
|
|
|
impl Default for TransactionStatusMeta {
|
|
|
|
fn default() -> Self {
|
|
|
|
Self {
|
|
|
|
status: Ok(()),
|
|
|
|
fee: 0,
|
|
|
|
pre_balances: vec![],
|
|
|
|
post_balances: vec![],
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-01 13:06:40 -07:00
|
|
|
/// A duplicate representation of TransactionStatusMeta with `err` field
|
2020-04-04 16:13:26 -07:00
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
2020-07-01 13:06:40 -07:00
|
|
|
pub struct UiTransactionStatusMeta {
|
2020-04-04 16:13:26 -07:00
|
|
|
pub err: Option<TransactionError>,
|
|
|
|
pub status: Result<()>, // This field is deprecated. See https://github.com/solana-labs/solana/issues/9302
|
|
|
|
pub fee: u64,
|
|
|
|
pub pre_balances: Vec<u64>,
|
|
|
|
pub post_balances: Vec<u64>,
|
|
|
|
}
|
|
|
|
|
2020-07-01 13:06:40 -07:00
|
|
|
impl From<TransactionStatusMeta> for UiTransactionStatusMeta {
|
2020-04-04 16:13:26 -07:00
|
|
|
fn from(meta: TransactionStatusMeta) -> Self {
|
|
|
|
Self {
|
|
|
|
err: meta.status.clone().err(),
|
|
|
|
status: meta.status,
|
|
|
|
fee: meta.fee,
|
|
|
|
pre_balances: meta.pre_balances,
|
|
|
|
post_balances: meta.post_balances,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-26 13:29:30 -07:00
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct TransactionStatus {
|
|
|
|
pub slot: Slot,
|
2020-04-15 20:51:05 -07:00
|
|
|
pub confirmations: Option<usize>, // None = rooted
|
2020-07-27 11:42:49 -07:00
|
|
|
pub status: Result<()>, // legacy field
|
2020-04-04 16:13:26 -07:00
|
|
|
pub err: Option<TransactionError>,
|
2020-03-26 13:29:30 -07:00
|
|
|
}
|
|
|
|
|
2020-04-06 03:04:54 -07:00
|
|
|
impl TransactionStatus {
|
|
|
|
pub fn satisfies_commitment(&self, commitment_config: CommitmentConfig) -> bool {
|
|
|
|
(commitment_config == CommitmentConfig::default() && self.confirmations.is_none())
|
|
|
|
|| commitment_config == CommitmentConfig::recent()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-07-27 11:42:49 -07:00
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct ConfirmedTransactionStatusWithSignature {
|
|
|
|
pub signature: Signature,
|
|
|
|
pub slot: Slot,
|
|
|
|
pub err: Option<TransactionError>,
|
|
|
|
pub memo: Option<String>,
|
|
|
|
}
|
|
|
|
|
2020-03-26 13:29:30 -07:00
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
pub struct Reward {
|
|
|
|
pub pubkey: String,
|
|
|
|
pub lamports: i64,
|
|
|
|
}
|
|
|
|
|
|
|
|
pub type Rewards = Vec<Reward>;
|
|
|
|
|
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct ConfirmedBlock {
|
|
|
|
pub previous_blockhash: String,
|
|
|
|
pub blockhash: String,
|
|
|
|
pub parent_slot: Slot,
|
|
|
|
pub transactions: Vec<TransactionWithStatusMeta>,
|
|
|
|
pub rewards: Rewards,
|
2020-07-09 21:47:29 -07:00
|
|
|
pub block_time: Option<UnixTimestamp>,
|
2020-03-26 13:29:30 -07:00
|
|
|
}
|
|
|
|
|
2020-09-23 22:10:29 -07:00
|
|
|
impl ConfirmedBlock {
|
|
|
|
pub fn encode(self, encoding: UiTransactionEncoding) -> EncodedConfirmedBlock {
|
|
|
|
EncodedConfirmedBlock {
|
|
|
|
previous_blockhash: self.previous_blockhash,
|
|
|
|
blockhash: self.blockhash,
|
|
|
|
parent_slot: self.parent_slot,
|
|
|
|
transactions: self
|
|
|
|
.transactions
|
|
|
|
.into_iter()
|
|
|
|
.map(|tx| tx.encode(encoding))
|
|
|
|
.collect(),
|
|
|
|
rewards: self.rewards,
|
|
|
|
block_time: self.block_time,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct EncodedConfirmedBlock {
|
|
|
|
pub previous_blockhash: String,
|
|
|
|
pub blockhash: String,
|
|
|
|
pub parent_slot: Slot,
|
|
|
|
pub transactions: Vec<EncodedTransactionWithStatusMeta>,
|
|
|
|
pub rewards: Rewards,
|
|
|
|
pub block_time: Option<UnixTimestamp>,
|
|
|
|
}
|
|
|
|
|
2020-04-08 23:57:30 -07:00
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct ConfirmedTransaction {
|
|
|
|
pub slot: Slot,
|
|
|
|
#[serde(flatten)]
|
|
|
|
pub transaction: TransactionWithStatusMeta,
|
|
|
|
}
|
|
|
|
|
2020-09-23 22:10:29 -07:00
|
|
|
impl ConfirmedTransaction {
|
|
|
|
pub fn encode(self, encoding: UiTransactionEncoding) -> EncodedConfirmedTransaction {
|
|
|
|
EncodedConfirmedTransaction {
|
|
|
|
slot: self.slot,
|
|
|
|
transaction: self.transaction.encode(encoding),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct EncodedConfirmedTransaction {
|
|
|
|
pub slot: Slot,
|
|
|
|
#[serde(flatten)]
|
|
|
|
pub transaction: EncodedTransactionWithStatusMeta,
|
|
|
|
}
|
|
|
|
|
2020-03-26 13:29:30 -07:00
|
|
|
/// A duplicate representation of a Transaction for pretty JSON serialization
|
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
2020-07-01 13:06:40 -07:00
|
|
|
pub struct UiTransaction {
|
2020-03-26 13:29:30 -07:00
|
|
|
pub signatures: Vec<String>,
|
2020-07-01 13:06:40 -07:00
|
|
|
pub message: UiMessage,
|
2020-03-26 13:29:30 -07:00
|
|
|
}
|
|
|
|
|
2020-06-19 15:15:13 -07:00
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase", untagged)]
|
2020-07-01 13:06:40 -07:00
|
|
|
pub enum UiMessage {
|
|
|
|
Parsed(UiParsedMessage),
|
|
|
|
Raw(UiRawMessage),
|
2020-06-19 15:15:13 -07:00
|
|
|
}
|
|
|
|
|
2020-07-01 13:06:40 -07:00
|
|
|
/// A duplicate representation of a Message, in raw format, for pretty JSON serialization
|
2020-03-26 13:29:30 -07:00
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
2020-07-01 13:06:40 -07:00
|
|
|
pub struct UiRawMessage {
|
2020-03-26 13:29:30 -07:00
|
|
|
pub header: MessageHeader,
|
|
|
|
pub account_keys: Vec<String>,
|
|
|
|
pub recent_blockhash: String,
|
2020-07-01 13:06:40 -07:00
|
|
|
pub instructions: Vec<UiCompiledInstruction>,
|
2020-03-26 13:29:30 -07:00
|
|
|
}
|
|
|
|
|
2020-07-01 13:06:40 -07:00
|
|
|
/// A duplicate representation of a Message, in parsed format, for pretty JSON serialization
|
2020-06-19 15:15:13 -07:00
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
2020-07-01 13:06:40 -07:00
|
|
|
pub struct UiParsedMessage {
|
2020-08-04 23:58:58 -07:00
|
|
|
pub account_keys: Vec<ParsedAccount>,
|
2020-06-19 15:15:13 -07:00
|
|
|
pub recent_blockhash: String,
|
2020-07-01 13:06:40 -07:00
|
|
|
pub instructions: Vec<UiInstruction>,
|
2020-06-19 15:15:13 -07:00
|
|
|
}
|
|
|
|
|
2020-09-23 22:10:29 -07:00
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
2020-03-26 13:29:30 -07:00
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct TransactionWithStatusMeta {
|
2020-09-23 22:10:29 -07:00
|
|
|
pub transaction: Transaction,
|
|
|
|
pub meta: Option<TransactionStatusMeta>,
|
|
|
|
}
|
|
|
|
|
|
|
|
impl TransactionWithStatusMeta {
|
|
|
|
fn encode(self, encoding: UiTransactionEncoding) -> EncodedTransactionWithStatusMeta {
|
|
|
|
EncodedTransactionWithStatusMeta {
|
|
|
|
transaction: EncodedTransaction::encode(self.transaction, encoding),
|
|
|
|
meta: self.meta.map(|meta| meta.into()),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase")]
|
|
|
|
pub struct EncodedTransactionWithStatusMeta {
|
2020-03-26 13:29:30 -07:00
|
|
|
pub transaction: EncodedTransaction,
|
2020-07-01 13:06:40 -07:00
|
|
|
pub meta: Option<UiTransactionStatusMeta>,
|
2020-03-26 13:29:30 -07:00
|
|
|
}
|
|
|
|
|
2020-07-27 08:23:17 -07:00
|
|
|
#[derive(Serialize, Deserialize, Clone, Copy, Debug, PartialEq)]
|
2020-03-26 13:29:30 -07:00
|
|
|
#[serde(rename_all = "camelCase")]
|
2020-07-01 13:06:40 -07:00
|
|
|
pub enum UiTransactionEncoding {
|
2020-08-15 22:06:39 -07:00
|
|
|
Binary, // Legacy. Retained for RPC backwards compatibility
|
|
|
|
Base64,
|
|
|
|
Base58,
|
2020-03-26 13:29:30 -07:00
|
|
|
Json,
|
2020-06-19 15:15:13 -07:00
|
|
|
JsonParsed,
|
2020-03-26 13:29:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
|
|
#[serde(rename_all = "camelCase", untagged)]
|
|
|
|
pub enum EncodedTransaction {
|
2020-08-15 17:56:09 -07:00
|
|
|
LegacyBinary(String), // Old way of expressing base-58, retained for RPC backwards compatibility
|
2020-08-14 23:53:58 -07:00
|
|
|
Binary(String, UiTransactionEncoding),
|
2020-07-01 13:06:40 -07:00
|
|
|
Json(UiTransaction),
|
2020-03-26 13:29:30 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
impl EncodedTransaction {
|
2020-07-01 13:06:40 -07:00
|
|
|
pub fn encode(transaction: Transaction, encoding: UiTransactionEncoding) -> Self {
|
2020-06-19 15:15:13 -07:00
|
|
|
match encoding {
|
2020-08-14 23:53:58 -07:00
|
|
|
UiTransactionEncoding::Binary => EncodedTransaction::LegacyBinary(
|
2020-06-19 15:15:13 -07:00
|
|
|
bs58::encode(bincode::serialize(&transaction).unwrap()).into_string(),
|
|
|
|
),
|
2020-08-15 22:06:39 -07:00
|
|
|
UiTransactionEncoding::Base58 => EncodedTransaction::Binary(
|
|
|
|
bs58::encode(bincode::serialize(&transaction).unwrap()).into_string(),
|
|
|
|
encoding,
|
|
|
|
),
|
|
|
|
UiTransactionEncoding::Base64 => EncodedTransaction::Binary(
|
2020-08-14 23:53:58 -07:00
|
|
|
base64::encode(bincode::serialize(&transaction).unwrap()),
|
|
|
|
encoding,
|
|
|
|
),
|
|
|
|
UiTransactionEncoding::Json | UiTransactionEncoding::JsonParsed => {
|
2020-07-01 13:06:40 -07:00
|
|
|
let message = if encoding == UiTransactionEncoding::Json {
|
|
|
|
UiMessage::Raw(UiRawMessage {
|
2020-06-19 15:15:13 -07:00
|
|
|
header: transaction.message.header,
|
|
|
|
account_keys: transaction
|
|
|
|
.message
|
|
|
|
.account_keys
|
|
|
|
.iter()
|
|
|
|
.map(|pubkey| pubkey.to_string())
|
|
|
|
.collect(),
|
|
|
|
recent_blockhash: transaction.message.recent_blockhash.to_string(),
|
|
|
|
instructions: transaction
|
|
|
|
.message
|
|
|
|
.instructions
|
|
|
|
.iter()
|
|
|
|
.map(|instruction| instruction.into())
|
|
|
|
.collect(),
|
|
|
|
})
|
|
|
|
} else {
|
2020-07-01 13:06:40 -07:00
|
|
|
UiMessage::Parsed(UiParsedMessage {
|
2020-06-19 15:15:13 -07:00
|
|
|
account_keys: parse_accounts(&transaction.message),
|
|
|
|
recent_blockhash: transaction.message.recent_blockhash.to_string(),
|
|
|
|
instructions: transaction
|
|
|
|
.message
|
|
|
|
.instructions
|
|
|
|
.iter()
|
|
|
|
.map(|instruction| {
|
|
|
|
let program_id =
|
|
|
|
instruction.program_id(&transaction.message.account_keys);
|
2020-07-31 12:26:09 -07:00
|
|
|
if let Ok(parsed_instruction) = parse(
|
|
|
|
program_id,
|
|
|
|
instruction,
|
|
|
|
&transaction.message.account_keys,
|
|
|
|
) {
|
2020-08-04 23:58:58 -07:00
|
|
|
UiInstruction::Parsed(UiParsedInstruction::Parsed(
|
|
|
|
parsed_instruction,
|
|
|
|
))
|
2020-06-19 15:15:13 -07:00
|
|
|
} else {
|
2020-08-04 23:58:58 -07:00
|
|
|
UiInstruction::Parsed(UiParsedInstruction::PartiallyDecoded(
|
2020-08-03 13:27:15 -07:00
|
|
|
UiPartiallyDecodedInstruction::from(
|
|
|
|
instruction,
|
2020-08-04 23:58:58 -07:00
|
|
|
&transaction.message.account_keys,
|
|
|
|
),
|
2020-08-03 13:27:15 -07:00
|
|
|
))
|
2020-06-19 15:15:13 -07:00
|
|
|
}
|
|
|
|
})
|
|
|
|
.collect(),
|
|
|
|
})
|
|
|
|
};
|
2020-07-01 13:06:40 -07:00
|
|
|
EncodedTransaction::Json(UiTransaction {
|
2020-06-19 15:15:13 -07:00
|
|
|
signatures: transaction
|
|
|
|
.signatures
|
2020-03-26 13:29:30 -07:00
|
|
|
.iter()
|
2020-06-19 15:15:13 -07:00
|
|
|
.map(|sig| sig.to_string())
|
2020-03-26 13:29:30 -07:00
|
|
|
.collect(),
|
2020-06-19 15:15:13 -07:00
|
|
|
message,
|
|
|
|
})
|
|
|
|
}
|
2020-03-27 22:55:55 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
pub fn decode(&self) -> Option<Transaction> {
|
|
|
|
match self {
|
|
|
|
EncodedTransaction::Json(_) => None,
|
2020-08-14 23:53:58 -07:00
|
|
|
EncodedTransaction::LegacyBinary(blob) => bs58::decode(blob)
|
2020-03-27 22:55:55 -07:00
|
|
|
.into_vec()
|
|
|
|
.ok()
|
|
|
|
.and_then(|bytes| bincode::deserialize(&bytes).ok()),
|
2020-08-15 17:26:00 -07:00
|
|
|
EncodedTransaction::Binary(blob, encoding) => match *encoding {
|
2020-08-15 22:06:39 -07:00
|
|
|
UiTransactionEncoding::Base58 => bs58::decode(blob)
|
|
|
|
.into_vec()
|
2020-08-15 17:26:00 -07:00
|
|
|
.ok()
|
|
|
|
.and_then(|bytes| bincode::deserialize(&bytes).ok()),
|
2020-08-15 22:06:39 -07:00
|
|
|
UiTransactionEncoding::Base64 => base64::decode(blob)
|
2020-08-15 17:26:00 -07:00
|
|
|
.ok()
|
|
|
|
.and_then(|bytes| bincode::deserialize(&bytes).ok()),
|
2020-08-15 22:06:39 -07:00
|
|
|
UiTransactionEncoding::Binary
|
|
|
|
| UiTransactionEncoding::Json
|
|
|
|
| UiTransactionEncoding::JsonParsed => None,
|
2020-08-15 17:26:00 -07:00
|
|
|
},
|
2020-03-26 13:29:30 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2020-04-06 03:04:54 -07:00
|
|
|
|
|
|
|
#[cfg(test)]
|
|
|
|
mod test {
|
|
|
|
use super::*;
|
|
|
|
|
|
|
|
#[test]
|
|
|
|
fn test_satisfies_commitment() {
|
|
|
|
let status = TransactionStatus {
|
|
|
|
slot: 0,
|
|
|
|
confirmations: None,
|
|
|
|
status: Ok(()),
|
|
|
|
err: None,
|
|
|
|
};
|
|
|
|
|
|
|
|
assert!(status.satisfies_commitment(CommitmentConfig::default()));
|
|
|
|
assert!(status.satisfies_commitment(CommitmentConfig::recent()));
|
|
|
|
|
|
|
|
let status = TransactionStatus {
|
|
|
|
slot: 0,
|
|
|
|
confirmations: Some(10),
|
|
|
|
status: Ok(()),
|
|
|
|
err: None,
|
|
|
|
};
|
|
|
|
|
|
|
|
assert!(!status.satisfies_commitment(CommitmentConfig::default()));
|
|
|
|
assert!(status.satisfies_commitment(CommitmentConfig::recent()));
|
|
|
|
}
|
|
|
|
}
|