Add account-decoder utilities

Cargo.toml

@@ -54,6 +54,7 @@ members = [
     "sys-tuner",
     "tokens",
     "transaction-status",
+    "account-decoder",
     "upload-perf",
     "net-utils",
     "version",

account-decoder/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "solana-account-decoder"
+version = "1.3.0"
+description = "Solana account decoder"
+authors = ["Solana Maintainers <[email protected]>"]
+repository = "https://github.com/solana-labs/solana"
+homepage = "https://solana.com/"
+license = "Apache-2.0"
+edition = "2018"
+
+[dependencies]
+bincode = "1.2.1"
+bs58 = "0.3.1"
+Inflector = "0.11.4"
+lazy_static = "1.4.0"
+solana-sdk = { path = "../sdk", version = "1.3.0" }
+solana-vote-program = { path = "../programs/vote", version = "1.3.0" }
+spl-memo = "1.0.0"
+serde = "1.0.112"
+serde_derive = "1.0.103"
+serde_json = "1.0.54"
+thiserror = "1.0"
+
+[package.metadata.docs.rs]
+targets = ["x86_64-unknown-linux-gnu"]

account-decoder/src/lib.rs

@@ -0,0 +1,80 @@
+#[macro_use]
+extern crate lazy_static;
+#[macro_use]
+extern crate serde_derive;
+
+pub mod parse_account_data;
+pub mod parse_nonce;
+pub mod parse_vote;
+
+use crate::parse_account_data::parse_account_data;
+use serde_json::Value;
+use solana_sdk::{account::Account, clock::Epoch, pubkey::Pubkey};
+use std::str::FromStr;
+
+/// A duplicate representation of a Message for pretty JSON serialization
+#[derive(Serialize, Deserialize, Clone, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct EncodedAccount {
+    pub lamports: u64,
+    pub data: EncodedAccountData,
+    pub owner: String,
+    pub executable: bool,
+    pub rent_epoch: Epoch,
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase", untagged)]
+pub enum EncodedAccountData {
+    Binary(String),
+    Json(Value),
+}
+
+impl From<Vec<u8>> for EncodedAccountData {
+    fn from(data: Vec<u8>) -> Self {
+        Self::Binary(bs58::encode(data).into_string())
+    }
+}
+
+#[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum AccountEncoding {
+    Binary,
+    JsonParsed,
+}
+
+impl EncodedAccount {
+    pub fn encode(account: Account, encoding: AccountEncoding) -> Self {
+        let data = match encoding {
+            AccountEncoding::Binary => account.data.into(),
+            AccountEncoding::JsonParsed => {
+                if let Ok(parsed_data) = parse_account_data(&account.owner, &account.data) {
+                    EncodedAccountData::Json(parsed_data)
+                } else {
+                    account.data.into()
+                }
+            }
+        };
+        EncodedAccount {
+            lamports: account.lamports,
+            data,
+            owner: account.owner.to_string(),
+            executable: account.executable,
+            rent_epoch: account.rent_epoch,
+        }
+    }
+
+    pub fn decode(&self) -> Option<Account> {
+        let data = match &self.data {
+            EncodedAccountData::Json(_) => None,
+            EncodedAccountData::Binary(blob) => bs58::decode(blob).into_vec().ok(),
+        }?;
+        Some(Account {
+            lamports: self.lamports,
+            data,
+            owner: Pubkey::from_str(&self.owner).ok()?,
+            executable: self.executable,
+            rent_epoch: self.rent_epoch,
+        })
+    }
+}

account-decoder/src/parse_account_data.rs

@@ -0,0 +1,80 @@
+use crate::{parse_nonce::parse_nonce, parse_vote::parse_vote};
+use inflector::Inflector;
+use serde_json::{json, Value};
+use solana_sdk::{instruction::InstructionError, pubkey::Pubkey, system_program};
+use std::{collections::HashMap, str::FromStr};
+use thiserror::Error;
+
+lazy_static! {
+    static ref SYSTEM_PROGRAM_ID: Pubkey =
+        Pubkey::from_str(&system_program::id().to_string()).unwrap();
+    static ref VOTE_PROGRAM_ID: Pubkey =
+        Pubkey::from_str(&solana_vote_program::id().to_string()).unwrap();
+    pub static ref PARSABLE_PROGRAM_IDS: HashMap<Pubkey, ParsableAccount> = {
+        let mut m = HashMap::new();
+        m.insert(*SYSTEM_PROGRAM_ID, ParsableAccount::Nonce);
+        m.insert(*VOTE_PROGRAM_ID, ParsableAccount::Vote);
+        m
+    };
+}
+
+#[derive(Error, Debug)]
+pub enum ParseAccountError {
+    #[error("Program not parsable")]
+    ProgramNotParsable,
+
+    #[error("Instruction error")]
+    InstructionError(#[from] InstructionError),
+
+    #[error("Serde json error")]
+    SerdeJsonError(#[from] serde_json::error::Error),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum ParsableAccount {
+    Nonce,
+    Vote,
+}
+
+pub fn parse_account_data(program_id: &Pubkey, data: &[u8]) -> Result<Value, ParseAccountError> {
+    let program_name = PARSABLE_PROGRAM_IDS
+        .get(program_id)
+        .ok_or_else(|| ParseAccountError::ProgramNotParsable)?;
+    let parsed_json = match program_name {
+        ParsableAccount::Nonce => serde_json::to_value(parse_nonce(data)?)?,
+        ParsableAccount::Vote => serde_json::to_value(parse_vote(data)?)?,
+    };
+    Ok(json!({
+        format!("{:?}", program_name).to_kebab_case(): parsed_json
+    }))
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use solana_sdk::nonce::{
+        state::{Data, Versions},
+        State,
+    };
+    use solana_vote_program::vote_state::{VoteState, VoteStateVersions};
+
+    #[test]
+    fn test_parse_account_data() {
+        let other_program = Pubkey::new_rand();
+        let data = vec![0; 4];
+        assert!(parse_account_data(&other_program, &data).is_err());
+
+        let vote_state = VoteState::default();
+        let mut vote_account_data: Vec<u8> = vec![0; VoteState::size_of()];
+        let versioned = VoteStateVersions::Current(Box::new(vote_state));
+        VoteState::serialize(&versioned, &mut vote_account_data).unwrap();
+        let parsed = parse_account_data(&solana_vote_program::id(), &vote_account_data).unwrap();
+        assert!(parsed.as_object().unwrap().contains_key("vote"));
+
+        let nonce_data = Versions::new_current(State::Initialized(Data::default()));
+        let nonce_account_data = bincode::serialize(&nonce_data).unwrap();
+        let parsed = parse_account_data(&system_program::id(), &nonce_account_data).unwrap();
+        assert!(parsed.as_object().unwrap().contains_key("nonce"));
+    }
+}

account-decoder/src/parse_nonce.rs

@@ -0,0 +1,65 @@
+use crate::parse_account_data::ParseAccountError;
+use solana_sdk::{
+    fee_calculator::FeeCalculator,
+    instruction::InstructionError,
+    nonce::{state::Versions, State},
+};
+
+pub fn parse_nonce(data: &[u8]) -> Result<UiNonceState, ParseAccountError> {
+    let nonce_state: Versions = bincode::deserialize(data)
+        .map_err(|_| ParseAccountError::from(InstructionError::InvalidAccountData))?;
+    let nonce_state = nonce_state.convert_to_current();
+    match nonce_state {
+        State::Uninitialized => Ok(UiNonceState::Uninitialized),
+        State::Initialized(data) => Ok(UiNonceState::Initialized(UiNonceData {
+            authority: data.authority.to_string(),
+            blockhash: data.blockhash.to_string(),
+            fee_calculator: data.fee_calculator,
+        })),
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub enum UiNonceState {
+    Uninitialized,
+    Initialized(UiNonceData),
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
+#[serde(rename_all = "camelCase")]
+pub struct UiNonceData {
+    pub authority: String,
+    pub blockhash: String,
+    pub fee_calculator: FeeCalculator,
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use solana_sdk::{
+        hash::Hash,
+        nonce::{
+            state::{Data, Versions},
+            State,
+        },
+        pubkey::Pubkey,
+    };
+
+    #[test]
+    fn test_parse_nonce() {
+        let nonce_data = Versions::new_current(State::Initialized(Data::default()));
+        let nonce_account_data = bincode::serialize(&nonce_data).unwrap();
+        assert_eq!(
+            parse_nonce(&nonce_account_data).unwrap(),
+            UiNonceState::Initialized(UiNonceData {
+                authority: Pubkey::default().to_string(),
+                blockhash: Hash::default().to_string(),
+                fee_calculator: FeeCalculator::default(),
+            }),
+        );
+
+        let bad_data = vec![0; 4];
+        assert!(parse_nonce(&bad_data).is_err());
+    }
+}