Decode token instructions (solana-labs#11281)

* Token->SplToken

* Add spl_token instruction parsing

* Rebase on master

* Gracefully fail key len mismatches

Author: CriesofCarrots

Cargo.lock

@@ -16,7 +16,7 @@ lazy_static! {
     pub static ref PARSABLE_PROGRAM_IDS: HashMap<Pubkey, ParsableAccount> = {
         let mut m = HashMap::new();
         m.insert(*SYSTEM_PROGRAM_ID, ParsableAccount::Nonce);
-        m.insert(*TOKEN_PROGRAM_ID, ParsableAccount::Token);
+        m.insert(*TOKEN_PROGRAM_ID, ParsableAccount::SplToken);
         m.insert(*VOTE_PROGRAM_ID, ParsableAccount::Vote);
         m
     };
@@ -41,7 +41,7 @@ pub enum ParseAccountError {
 #[serde(rename_all = "camelCase")]
 pub enum ParsableAccount {
     Nonce,
-    Token,
+    SplToken,
     Vote,
 }
 
@@ -51,7 +51,7 @@ pub fn parse_account_data(program_id: &Pubkey, data: &[u8]) -> Result<Value, Par
         .ok_or_else(|| ParseAccountError::ProgramNotParsable)?;
     let parsed_json = match program_name {
         ParsableAccount::Nonce => serde_json::to_value(parse_nonce(data)?)?,
-        ParsableAccount::Token => serde_json::to_value(parse_token(data)?)?,
+        ParsableAccount::SplToken => serde_json::to_value(parse_token(data)?)?,
         ParsableAccount::Vote => serde_json::to_value(parse_vote(data)?)?,
     };
     Ok(json!({

account-decoder/src/parse_account_data.rs

@@ -16,7 +16,7 @@ pub fn parse_token(data: &[u8]) -> Result<TokenAccountType, ParseAccountError> {
     let mut data = data.to_vec();
     if data.len() == size_of::<Account>() {
         let account: Account = *State::unpack(&mut data)
-            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::Token))?;
+            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::SplToken))?;
         Ok(TokenAccountType::Account(UiTokenAccount {
             mint: account.mint.to_string(),
             owner: account.owner.to_string(),
@@ -31,7 +31,7 @@ pub fn parse_token(data: &[u8]) -> Result<TokenAccountType, ParseAccountError> {
         }))
     } else if data.len() == size_of::<Mint>() {
         let mint: Mint = *State::unpack(&mut data)
-            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::Token))?;
+            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::SplToken))?;
         Ok(TokenAccountType::Mint(UiMint {
             owner: match mint.owner {
                 COption::Some(pubkey) => Some(pubkey.to_string()),
@@ -42,7 +42,7 @@ pub fn parse_token(data: &[u8]) -> Result<TokenAccountType, ParseAccountError> {
         }))
     } else if data.len() == size_of::<Multisig>() {
         let multisig: Multisig = *State::unpack(&mut data)
-            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::Token))?;
+            .map_err(|_| ParseAccountError::AccountNotParsable(ParsableAccount::SplToken))?;
         Ok(TokenAccountType::Multisig(UiMultisig {
             num_required_signers: multisig.m,
             num_valid_signers: multisig.n,
@@ -61,7 +61,7 @@ pub fn parse_token(data: &[u8]) -> Result<TokenAccountType, ParseAccountError> {
         }))
     } else {
         Err(ParseAccountError::AccountNotParsable(
-            ParsableAccount::Token,
+            ParsableAccount::SplToken,
         ))
     }
 }

account-decoder/src/parse_token.rs

@@ -13,13 +13,16 @@ bincode = "1.3.1"
 bs58 = "0.3.1"
 Inflector = "0.11.4"
 lazy_static = "1.4.0"
+solana-account-decoder = { path = "../account-decoder", version = "1.3.0" }
 solana-sdk = { path = "../sdk", version = "1.3.0" }
 solana-stake-program = { path = "../programs/stake", version = "1.3.0" }
 solana-vote-program = { path = "../programs/vote", version = "1.3.0" }
 spl-memo-v1-0 = { package = "spl-memo", version = "1.0.4", features = ["skip-no-mangle"] }
+spl-token-v1-0 = { package = "spl-token", version = "1.0.2", features = ["skip-no-mangle"] }
 serde = "1.0.112"
 serde_derive = "1.0.103"
 serde_json = "1.0.56"
+thiserror = "1.0"
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

transaction-status/Cargo.toml

@@ -5,6 +5,7 @@ extern crate serde_derive;
 
 pub mod parse_accounts;
 pub mod parse_instruction;
+pub mod parse_token;
 
 use crate::{parse_accounts::parse_accounts, parse_instruction::parse};
 use serde_json::Value;
@@ -220,7 +221,11 @@ impl EncodedTransaction {
                             .map(|instruction| {
                                 let program_id =
                                     instruction.program_id(&transaction.message.account_keys);
-                                if let Some(parsed_instruction) = parse(program_id, instruction) {
+                                if let Ok(parsed_instruction) = parse(
+                                    program_id,
+                                    instruction,
+                                    &transaction.message.account_keys,
+                                ) {
                                     UiInstruction::Parsed(parsed_instruction)
                                 } else {
                                     UiInstruction::Compiled(instruction.into())

transaction-status/src/lib.rs

@@ -1,34 +1,60 @@
+use crate::parse_token::parse_token;
 use inflector::Inflector;
 use serde_json::{json, Value};
+use solana_account_decoder::parse_token::spl_token_id_v1_0;
 use solana_sdk::{instruction::CompiledInstruction, pubkey::Pubkey};
 use std::{
     collections::HashMap,
     str::{from_utf8, FromStr},
 };
+use thiserror::Error;
 
 lazy_static! {
     static ref MEMO_PROGRAM_ID: Pubkey =
         Pubkey::from_str(&spl_memo_v1_0::id().to_string()).unwrap();
+    static ref TOKEN_PROGRAM_ID: Pubkey = spl_token_id_v1_0();
     static ref PARSABLE_PROGRAM_IDS: HashMap<Pubkey, ParsableProgram> = {
         let mut m = HashMap::new();
         m.insert(*MEMO_PROGRAM_ID, ParsableProgram::SplMemo);
+        m.insert(*TOKEN_PROGRAM_ID, ParsableProgram::SplToken);
         m
     };
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Error, Debug, PartialEq)]
+pub enum ParseInstructionError {
+    #[error("{0:?} instruction not parsable")]
+    InstructionNotParsable(ParsableProgram),
+
+    #[error("{0:?} instruction key mismatch")]
+    InstructionKeyMismatch(ParsableProgram),
+
+    #[error("Program not parsable")]
+    ProgramNotParsable,
+}
+
+#[derive(Debug, Serialize, Deserialize, PartialEq)]
 #[serde(rename_all = "camelCase")]
-enum ParsableProgram {
+pub enum ParsableProgram {
     SplMemo,
+    SplToken,
 }
 
-pub fn parse(program_id: &Pubkey, instruction: &CompiledInstruction) -> Option<Value> {
-    PARSABLE_PROGRAM_IDS.get(program_id).map(|program_name| {
-        let parsed_json = match program_name {
-            ParsableProgram::SplMemo => parse_memo(instruction),
-        };
-        json!({ format!("{:?}", program_name).to_kebab_case(): parsed_json })
-    })
+pub fn parse(
+    program_id: &Pubkey,
+    instruction: &CompiledInstruction,
+    account_keys: &[Pubkey],
+) -> Result<Value, ParseInstructionError> {
+    let program_name = PARSABLE_PROGRAM_IDS
+        .get(program_id)
+        .ok_or_else(|| ParseInstructionError::ProgramNotParsable)?;
+    let parsed_json = match program_name {
+        ParsableProgram::SplMemo => parse_memo(instruction),
+        ParsableProgram::SplToken => parse_token(instruction, account_keys)?,
+    };
+    Ok(json!({
+        format!("{:?}", program_name).to_kebab_case(): parsed_json
+    }))
 }
 
 fn parse_memo(instruction: &CompiledInstruction) -> Value {
@@ -50,11 +76,14 @@ mod test {
             "spl-memo": "🦖"
         });
         assert_eq!(
-            parse(&MEMO_PROGRAM_ID, &memo_instruction),
-            Some(expected_json)
+            parse(&MEMO_PROGRAM_ID, &memo_instruction, &[]).unwrap(),
+            expected_json
         );
 
         let non_parsable_program_id = Pubkey::new(&[1; 32]);
-        assert_eq!(parse(&non_parsable_program_id, &memo_instruction), None);
+        assert_eq!(
+            parse(&non_parsable_program_id, &memo_instruction, &[]).unwrap_err(),
+            ParseInstructionError::ProgramNotParsable
+        );
     }
 }