rpc: rework binary encoding. BREAKING CHANGE (bp #11646)

account-decoder/src/lib.rs

@@ -32,17 +32,18 @@ pub struct UiAccount {
 #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase", untagged)]
 pub enum UiAccountData {
-    Binary(String),
+    LegacyBinary(String), // Legacy. Retained for RPC backwards compatibility
     Json(ParsedAccount),
-    Binary64(String),
+    Binary(String, UiAccountEncoding),
 }
 
 #[derive(Serialize, Deserialize, Clone, Debug, PartialEq)]
 #[serde(rename_all = "camelCase")]
 pub enum UiAccountEncoding {
-    Binary, // SLOW! Avoid this encoding
+    Binary, // Legacy. Retained for RPC backwards compatibility
+    Base58,
+    Base64,
     JsonParsed,
-    Binary64,
 }
 
 impl UiAccount {
@@ -54,20 +55,24 @@ impl UiAccount {
         data_slice_config: Option<UiDataSliceConfig>,
     ) -> Self {
         let data = match encoding {
-            UiAccountEncoding::Binary => UiAccountData::Binary(
+            UiAccountEncoding::Binary => UiAccountData::LegacyBinary(
                 bs58::encode(slice_data(&account.data, data_slice_config)).into_string(),
             ),
-            UiAccountEncoding::Binary64 => UiAccountData::Binary64(base64::encode(slice_data(
-                &account.data,
-                data_slice_config,
-            ))),
+            UiAccountEncoding::Base58 => UiAccountData::Binary(
+                bs58::encode(slice_data(&account.data, data_slice_config)).into_string(),
+                encoding,
+            ),
+            UiAccountEncoding::Base64 => UiAccountData::Binary(
+                base64::encode(slice_data(&account.data, data_slice_config)),
+                encoding,
+            ),
             UiAccountEncoding::JsonParsed => {
                 if let Ok(parsed_data) =
                     parse_account_data(pubkey, &account.owner, &account.data, additional_data)
                 {
                     UiAccountData::Json(parsed_data)
                 } else {
-                    UiAccountData::Binary64(base64::encode(&account.data))
+                    UiAccountData::Binary(base64::encode(&account.data), UiAccountEncoding::Base64)
                 }
             }
         };
@@ -83,8 +88,12 @@ impl UiAccount {
     pub fn decode(&self) -> Option<Account> {
         let data = match &self.data {
             UiAccountData::Json(_) => None,
-            UiAccountData::Binary(blob) => bs58::decode(blob).into_vec().ok(),
-            UiAccountData::Binary64(blob) => base64::decode(blob).ok(),
+            UiAccountData::LegacyBinary(blob) => bs58::decode(blob).into_vec().ok(),
+            UiAccountData::Binary(blob, encoding) => match encoding {
+                UiAccountEncoding::Base58 => bs58::decode(blob).into_vec().ok(),
+                UiAccountEncoding::Base64 => base64::decode(blob).ok(),
+                UiAccountEncoding::Binary | UiAccountEncoding::JsonParsed => None,
+            },
         }?;
         Some(Account {
             lamports: self.lamports,

cli/src/cli.rs

@@ -11,7 +11,7 @@ use crate::{
     vote::*,
 };
 use chrono::prelude::*;
-use clap::{App, AppSettings, Arg, ArgMatches, SubCommand};
+use clap::{value_t_or_exit, App, AppSettings, Arg, ArgMatches, SubCommand};
 use log::*;
 use num_traits::FromPrimitive;
 use serde_json::{self, json, Value};
@@ -845,9 +845,14 @@ pub fn parse_command(
             _ => Err(CliError::BadParameter("Invalid signature".to_string())),
         },
         ("decode-transaction", Some(matches)) => {
-            let encoded_transaction = EncodedTransaction::Binary(
-                matches.value_of("base58_transaction").unwrap().to_string(),
-            );
+            let blob = value_t_or_exit!(matches, "transaction", String);
+            let encoding = match matches.value_of("encoding").unwrap() {
+                "base58" => UiTransactionEncoding::Binary,
+                "base64" => UiTransactionEncoding::Base64,
+                _ => unreachable!(),
+            };
+
+            let encoded_transaction = EncodedTransaction::Binary(blob, encoding);
             if let Some(transaction) = encoded_transaction.decode() {
                 Ok(CliCommandInfo {
                     command: CliCommand::DecodeTransaction(transaction),
@@ -1178,7 +1183,7 @@ fn process_confirm(
             if let Some(transaction_status) = status {
                 if config.verbose {
                     match rpc_client
-                        .get_confirmed_transaction(signature, UiTransactionEncoding::Binary)
+                        .get_confirmed_transaction(signature, UiTransactionEncoding::Base64)
                     {
                         Ok(confirmed_transaction) => {
                             println!(
@@ -1234,7 +1239,7 @@ fn process_show_account(
             account: UiAccount::encode(
                 account_pubkey,
                 account,
-                UiAccountEncoding::Binary64,
+                UiAccountEncoding::Base64,
                 None,
                 None,
             ),
@@ -2549,12 +2554,22 @@ pub fn app<'ab, 'v>(name: &str, about: &'ab str, version: &'v str) -> App<'ab, '
             SubCommand::with_name("decode-transaction")
                 .about("Decode a base-58 binary transaction")
                 .arg(
-                    Arg::with_name("base58_transaction")
+                    Arg::with_name("transaction")
                         .index(1)
-                        .value_name("BASE58_TRANSACTION")
+                        .value_name("TRANSACTION")
+                        .takes_value(true)
+                        .required(true)
+                        .help("transaction to decode"),
+                )
+                .arg(
+                    Arg::with_name("encoding")
+                        .index(2)
+                        .value_name("ENCODING")
+                        .possible_values(&["base58", "base64"]) // Subset of `UiTransactionEncoding` enum
+                        .default_value("base58")
                         .takes_value(true)
                         .required(true)
-                        .help("The transaction to decode"),
+                        .help("transaction encoding"),
                 ),
         )
         .subcommand(

cli/src/offline/blockhash_query.rs

@@ -348,7 +348,7 @@ mod tests {
         let rpc_nonce_account = UiAccount::encode(
             &nonce_pubkey,
             nonce_account,
-            UiAccountEncoding::Binary64,
+            UiAccountEncoding::Base64,
             None,
             None,
         );

client/src/rpc_client.rs

@@ -15,12 +15,7 @@ use bincode::serialize;
 use indicatif::{ProgressBar, ProgressStyle};
 use log::*;
 use serde_json::{json, Value};
-use solana_account_decoder::{
-    parse_token::UiTokenAmount,
-    UiAccount,
-    UiAccountData::{Binary, Binary64},
-    UiAccountEncoding,
-};
+use solana_account_decoder::{parse_token::UiTokenAmount, UiAccount, UiAccountEncoding};
 use solana_sdk::{
     account::Account,
     clock::{
@@ -477,7 +472,7 @@ impl RpcClient {
         commitment_config: CommitmentConfig,
     ) -> RpcResult<Option<Account>> {
         let config = RpcAccountInfoConfig {
-            encoding: Some(UiAccountEncoding::Binary64),
+            encoding: Some(UiAccountEncoding::Base64),
             commitment: Some(commitment_config),
             data_slice: None,
         };
@@ -495,17 +490,8 @@ impl RpcClient {
                 }
                 let Response {
                     context,
-                    value: mut rpc_account,
+                    value: rpc_account,
                 } = serde_json::from_value::<Response<Option<UiAccount>>>(result_json)?;
-                if let Some(ref mut account) = rpc_account {
-                    if let Binary(_) = &account.data {
-                        let tmp = Binary64(String::new());
-                        match std::mem::replace(&mut account.data, tmp) {
-                            Binary(new_data) => account.data = Binary64(new_data),
-                            _ => panic!("should have gotten binary here."),
-                        }
-                    }
-                }
                 trace!("Response account {:?} {:?}", pubkey, rpc_account);
                 let account = rpc_account.and_then(|rpc_account| rpc_account.decode());
                 Ok(Response {

core/src/rpc.rs

@@ -195,8 +195,11 @@ impl JsonRpcRequestProcessor {
         if let Some(account) = bank.get_account(pubkey) {
             if account.owner == spl_token_id_v1_0() && encoding == UiAccountEncoding::JsonParsed {
                 response = Some(get_parsed_token_account(bank.clone(), pubkey, account));
-            } else if encoding == UiAccountEncoding::Binary && account.data.len() > 128 {
-                let message = "Encoded binary (base 58) data should be less than 128 bytes, please use Binary64 encoding.".to_string();
+            } else if (encoding == UiAccountEncoding::Binary
+                || encoding == UiAccountEncoding::Base58)
+                && account.data.len() > 128
+            {
+                let message = "Encoded binary (base 58) data should be less than 128 bytes, please use Base64 encoding.".to_string();
                 return Err(error::Error {
                     code: error::ErrorCode::InvalidRequest,
                     message,
@@ -1239,7 +1242,7 @@ fn check_slice_and_encoding(encoding: &UiAccountEncoding, data_slice_is_some: bo
         UiAccountEncoding::JsonParsed => {
             if data_slice_is_some {
                 let message =
-                    "Sliced account data can only be encoded using binary (base 58) or binary64 encoding."
+                    "Sliced account data can only be encoded using binary (base 58) or base64 encoding."
                         .to_string();
                 Err(error::Error {
                     code: error::ErrorCode::InvalidRequest,
@@ -1250,7 +1253,7 @@ fn check_slice_and_encoding(encoding: &UiAccountEncoding, data_slice_is_some: bo
                 Ok(())
             }
         }
-        UiAccountEncoding::Binary | UiAccountEncoding::Binary64 => Ok(()),
+        UiAccountEncoding::Binary | UiAccountEncoding::Base58 | UiAccountEncoding::Base64 => Ok(()),
     }
 }
 
@@ -3073,13 +3076,13 @@ pub mod tests {
             "result": {
                 "context":{"slot":0},
                 "value":{
-                "owner": "11111111111111111111111111111111",
-                "lamports": 20,
-                "data": "",
-                "executable": false,
-                "rentEpoch": 0
-            },
+                    "owner": "11111111111111111111111111111111",
+                    "lamports": 20,
+                    "data": "",
+                    "executable": false,
+                    "rentEpoch": 0
                 },
+            },
             "id": 1,
         });
         let expected: Response =
@@ -3095,24 +3098,27 @@ pub mod tests {
         bank.store_account(&address, &account);
 
         let req = format!(
-            r#"{{"jsonrpc":"2.0","id":1,"method":"getAccountInfo","params":["{}", {{"encoding":"binary64"}}]}}"#,
+            r#"{{"jsonrpc":"2.0","id":1,"method":"getAccountInfo","params":["{}", {{"encoding":"base64"}}]}}"#,
             address
         );
         let res = io.handle_request_sync(&req, meta.clone());
         let result: Value = serde_json::from_str(&res.expect("actual response"))
             .expect("actual response deserialization");
-        assert_eq!(result["result"]["value"]["data"], base64::encode(&data));
+        assert_eq!(
+            result["result"]["value"]["data"],
+            json!([base64::encode(&data), "base64"]),
+        );
 
         let req = format!(
-            r#"{{"jsonrpc":"2.0","id":1,"method":"getAccountInfo","params":["{}", {{"encoding":"binary64", "dataSlice": {{"length": 2, "offset": 1}}}}]}}"#,
+            r#"{{"jsonrpc":"2.0","id":1,"method":"getAccountInfo","params":["{}", {{"encoding":"base64", "dataSlice": {{"length": 2, "offset": 1}}}}]}}"#,
             address
         );
         let res = io.handle_request_sync(&req, meta.clone());
         let result: Value = serde_json::from_str(&res.expect("actual response"))
             .expect("actual response deserialization");
         assert_eq!(
             result["result"]["value"]["data"],
-            base64::encode(&data[1..3]),
+            json!([base64::encode(&data[1..3]), "base64"]),
         );
 
         let req = format!(
@@ -4327,7 +4333,7 @@ pub mod tests {
         for TransactionWithStatusMeta { transaction, meta } in
             confirmed_block.transactions.into_iter()
         {
-            if let EncodedTransaction::Binary(transaction) = transaction {
+            if let EncodedTransaction::LegacyBinary(transaction) = transaction {
                 let decoded_transaction: Transaction =
                     deserialize(&bs58::decode(&transaction).into_vec().unwrap()).unwrap();
                 if decoded_transaction.signatures[0] == confirmed_block_signatures[0] {

core/tests/rpc.rs

@@ -103,7 +103,7 @@ fn test_rpc_send_tx() {
     use solana_account_decoder::UiAccountEncoding;
     use solana_client::rpc_config::RpcAccountInfoConfig;
     let config = RpcAccountInfoConfig {
-        encoding: Some(UiAccountEncoding::Binary64),
+        encoding: Some(UiAccountEncoding::Base64),
         commitment: None,
         data_slice: None,
     };