base → base58 (#7462)

Referring to base58 encoding as ‘base’ is quite confusing.  It’s not
only ambiguous but also by just using ‘base’ it’s not even clear that
code is referring to binary-to-text encoding schema.

Rename to_base and from_base methods to to_base58 and from_base58
respectively.  Furthermore, for CryptoHash prefer to_string rather
than to_base58.

chain/chain-primitives/src/error.rs

@@ -6,7 +6,6 @@ use near_primitives::time::Utc;
 use near_primitives::block::BlockValidityError;
 use near_primitives::challenge::{ChunkProofs, ChunkState};
 use near_primitives::errors::{EpochError, StorageError};
-use near_primitives::serialize::to_base;
 use near_primitives::shard_layout::ShardLayoutError;
 use near_primitives::sharding::{ChunkHash, ShardChunkHeader};
 use near_primitives::types::{BlockHeight, EpochId, ShardId};
@@ -299,7 +298,7 @@ impl From<EpochError> for Error {
     fn from(error: EpochError) -> Self {
         match error {
             EpochError::EpochOutOfBounds(epoch_id) => Error::EpochOutOfBounds(epoch_id),
-            EpochError::MissingBlock(h) => Error::DBNotFoundErr(to_base(&h)),
+            EpochError::MissingBlock(h) => Error::DBNotFoundErr(h.to_string()),
             err => Error::ValidatorError(err.to_string()),
         }
     }

chain/chain/src/test_utils.rs

@@ -24,7 +24,6 @@ use near_primitives::epoch_manager::epoch_info::EpochInfo;
 use near_primitives::errors::{EpochError, InvalidTxError};
 use near_primitives::hash::{hash, CryptoHash};
 use near_primitives::receipt::{ActionReceipt, Receipt, ReceiptEnum};
-use near_primitives::serialize::to_base;
 use near_primitives::shard_layout;
 use near_primitives::shard_layout::{ShardLayout, ShardUId};
 use near_primitives::sharding::ChunkHash;
@@ -305,7 +304,7 @@ impl KeyValueRuntime {
         }
         let prev_block_header = self
             .get_block_header(&prev_hash)?
-            .ok_or_else(|| Error::DBNotFoundErr(to_base(&prev_hash)))?;
+            .ok_or_else(|| Error::DBNotFoundErr(prev_hash.to_string()))?;
 
         let mut hash_to_epoch = self.hash_to_epoch.write().unwrap();
         let mut hash_to_next_epoch_approvals_req =
@@ -1274,7 +1273,7 @@ impl RuntimeAdapter for KeyValueRuntime {
         loop {
             let header = self
                 .get_block_header(&candidate_hash)?
-                .ok_or_else(|| Error::DBNotFoundErr(to_base(&candidate_hash)))?;
+                .ok_or_else(|| Error::DBNotFoundErr(candidate_hash.to_string()))?;
             candidate_hash = *header.prev_hash();
             if self.is_next_block_epoch_start(&candidate_hash)? {
                 break Ok(self.get_epoch_and_valset(candidate_hash)?.0);
@@ -1394,8 +1393,10 @@ pub fn setup_with_validators(
     (chain, runtime, signers)
 }
 
-pub fn format_hash(h: CryptoHash) -> String {
-    to_base(&h)[..6].to_string()
+pub fn format_hash(hash: CryptoHash) -> String {
+    let mut hash = hash.to_string();
+    hash.truncate(6);
+    hash
 }
 
 /// Displays chain from given store.

chain/jsonrpc/fuzz/fuzz_targets/fuzz_target_1.rs

@@ -122,7 +122,7 @@ impl Serialize for Base58String {
     where
         S: Serializer,
     {
-        let serialised = near_primitives::serialize::to_base(&self.0);
+        let serialised = near_primitives::serialize::to_base58(&self.0);
         serializer.serialize_newtype_struct("Base58String", &serialised)
     }
 }

chain/jsonrpc/jsonrpc-tests/tests/rpc_transactions.rs

@@ -10,7 +10,7 @@ use near_jsonrpc::client::new_client;
 use near_logger_utils::{init_integration_logger, init_test_logger};
 use near_network::test_utils::WaitOrTimeoutActor;
 use near_primitives::hash::{hash, CryptoHash};
-use near_primitives::serialize::{to_base, to_base64};
+use near_primitives::serialize::to_base64;
 use near_primitives::transaction::SignedTransaction;
 use near_primitives::types::BlockReference;
 use near_primitives::views::FinalExecutionStatus;
@@ -190,7 +190,7 @@ fn test_replay_protection() {
 #[test]
 fn test_tx_status_missing_tx() {
     test_with_client!(test_utils::NodeType::Validator, client, async move {
-        match client.tx(to_base(&CryptoHash::default()), "test1".parse().unwrap()).await {
+        match client.tx(CryptoHash::new().to_string(), "test1".parse().unwrap()).await {
             Err(e) => {
                 let s = serde_json::to_string(&e.data.unwrap()).unwrap();
                 assert_eq!(s, "\"Transaction 11111111111111111111111111111111 doesn't exist\"");

chain/jsonrpc/src/api/query.rs

@@ -14,14 +14,14 @@ const QUERY_DATA_MAX_SIZE: usize = 10 * 1024;
 
 impl RpcRequest for RpcQueryRequest {
     fn parse(value: Option<Value>) -> Result<Self, RpcParseError> {
-        let query_request = if let Ok((path, data)) =
-            parse_params::<(String, String)>(value.clone())
-        {
+        let params = parse_params::<(String, String)>(value.clone());
+        let query_request = if let Ok((path, data)) = params {
             // Handle a soft-deprecated version of the query API, which is based on
             // positional arguments with a "path"-style first argument.
             //
             // This whole block can be removed one day, when the new API is 100% adopted.
-            let data = serialize::from_base(&data).map_err(|err| RpcParseError(err.to_string()))?;
+            let data =
+                serialize::from_base58(&data).map_err(|err| RpcParseError(err.to_string()))?;
             let query_data_size = path.len() + data.len();
             if query_data_size > QUERY_DATA_MAX_SIZE {
                 return Err(RpcParseError(format!(

core/primitives-core/src/account.rs

@@ -214,15 +214,14 @@ mod tests {
     use borsh::BorshSerialize;
 
     use crate::hash::hash;
-    use crate::serialize::to_base;
 
     use super::*;
 
     #[test]
     fn test_account_serialization() {
         let acc = Account::new(1_000_000, 1_000_000, CryptoHash::default(), 100);
         let bytes = acc.try_to_vec().unwrap();
-        assert_eq!(to_base(&hash(&bytes)), "EVk5UaxBe8LQ8r8iD5EAxVBs6TJcMDKqyH7PBuho6bBJ");
+        assert_eq!(hash(&bytes).to_string(), "EVk5UaxBe8LQ8r8iD5EAxVBs6TJcMDKqyH7PBuho6bBJ");
     }
 
     #[test]

core/primitives-core/src/logging.rs

@@ -1,6 +1,6 @@
 use std::fmt::Debug;
 
-use crate::serialize::to_base;
+use crate::serialize::to_base58;
 
 const VECTOR_MAX_LENGTH: usize = 5;
 const STRING_PRINT_LEN: usize = 128;
@@ -37,7 +37,7 @@ pub fn pretty_utf8(buf: &[u8]) -> String {
         Ok(s) => pretty_hash(s),
         Err(_) => {
             if buf.len() <= STRING_PRINT_LEN {
-                pretty_hash(&to_base(buf))
+                pretty_hash(&to_base58(buf))
             } else {
                 pretty_vec(buf)
             }

core/primitives-core/src/serialize.rs

@@ -1,8 +1,8 @@
-pub fn to_base<T: AsRef<[u8]>>(input: T) -> String {
+pub fn to_base58<T: AsRef<[u8]>>(input: T) -> String {
     bs58::encode(input).into_string()
 }
 
-pub fn from_base(s: &str) -> Result<Vec<u8>, Box<dyn std::error::Error + Send + Sync>> {
+pub fn from_base58(s: &str) -> Result<Vec<u8>, Box<dyn std::error::Error + Send + Sync>> {
     bs58::decode(s).into_vec().map_err(|err| err.into())
 }
 
@@ -92,33 +92,33 @@ fn test_option_base64_format() {
     assert_round_trip("{\"field\":null}", Test { field: None });
 }
 
-pub mod base_bytes_format {
+pub mod base58_format {
     use serde::de;
     use serde::{Deserialize, Deserializer, Serializer};
 
-    use super::{from_base, to_base};
+    use super::{from_base58, to_base58};
 
     pub fn serialize<S>(data: &[u8], serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
     {
-        serializer.serialize_str(&to_base(data))
+        serializer.serialize_str(&to_base58(data))
     }
 
     pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
     where
         D: Deserializer<'de>,
     {
         let s = String::deserialize(deserializer)?;
-        from_base(&s).map_err(|err| de::Error::custom(err.to_string()))
+        from_base58(&s).map_err(|err| de::Error::custom(err.to_string()))
     }
 }
 
 #[test]
 fn test_base_bytes_format() {
     #[derive(PartialEq, Debug, serde::Deserialize, serde::Serialize)]
     struct Test {
-        #[serde(with = "base_bytes_format")]
+        #[serde(with = "base58_format")]
         field: Vec<u8>,
     }
 

core/primitives/src/transaction.rs

@@ -465,7 +465,6 @@ mod tests {
     use near_crypto::{InMemorySigner, KeyType, Signature, Signer};
 
     use crate::account::{AccessKeyPermission, FunctionCallPermission};
-    use crate::serialize::to_base;
 
     use super::*;
 
@@ -537,7 +536,7 @@ mod tests {
             SignedTransaction::try_from_slice(&signed_tx.try_to_vec().unwrap()).unwrap();
 
         assert_eq!(
-            to_base(&new_signed_tx.get_hash()),
+            new_signed_tx.get_hash().to_string(),
             "4GXvjMFN6wSxnU9jEVT8HbXP5Yk6yELX9faRSKp6n9fX"
         );
     }

core/store/src/lib.rs

@@ -19,7 +19,7 @@ use near_primitives::contract::ContractCode;
 pub use near_primitives::errors::StorageError;
 use near_primitives::hash::CryptoHash;
 use near_primitives::receipt::{DelayedReceiptIndices, Receipt, ReceivedData};
-use near_primitives::serialize::to_base;
+use near_primitives::serialize::to_base58;
 pub use near_primitives::shard_layout::ShardUId;
 use near_primitives::trie_key::{trie_key_parsers, TrieKey};
 use near_primitives::types::{AccountId, CompiledContractCache, StateRoot};
@@ -90,7 +90,7 @@ impl Store {
             target: "store",
             db_op = "get",
             col = %column,
-            key = %to_base(key),
+            key = %to_base58(key),
             size = value.as_ref().map(Vec::len)
         );
         Ok(value)
@@ -387,16 +387,16 @@ impl StoreUpdate {
         for op in &self.transaction.ops {
             match op {
                 DBOp::Insert { col, key, value } => {
-                    tracing::trace!(target: "store", db_op = "insert", col = %col, key =  %to_base(key), size = value.len())
+                    tracing::trace!(target: "store", db_op = "insert", col = %col, key = %to_base58(key), size = value.len())
                 }
                 DBOp::Set { col, key, value } => {
-                    tracing::trace!(target: "store", db_op = "set", col = %col, key =  %to_base(key), size = value.len())
+                    tracing::trace!(target: "store", db_op = "set", col = %col, key = %to_base58(key), size = value.len())
                 }
                 DBOp::UpdateRefcount { col, key, value } => {
-                    tracing::trace!(target: "store", db_op = "update_rc", col = %col, key =  %to_base(key), size = value.len())
+                    tracing::trace!(target: "store", db_op = "update_rc", col = %col, key = %to_base58(key), size = value.len())
                 }
                 DBOp::Delete { col, key } => {
-                    tracing::trace!(target: "store", db_op = "delete", col = %col, key =  %to_base(key))
+                    tracing::trace!(target: "store", db_op = "delete", col = %col, key = %to_base58(key))
                 }
                 DBOp::DeleteAll { col } => {
                     tracing::trace!(target: "store", db_op = "delete_all", col = %col)
@@ -412,10 +412,12 @@ impl fmt::Debug for StoreUpdate {
         writeln!(f, "Store Update {{")?;
         for op in self.transaction.ops.iter() {
             match op {
-                DBOp::Insert { col, key, .. } => writeln!(f, "  + {col} {}", to_base(key))?,
-                DBOp::Set { col, key, .. } => writeln!(f, "  = {col} {}", to_base(key))?,
-                DBOp::UpdateRefcount { col, key, .. } => writeln!(f, "  ± {col} {}", to_base(key))?,
-                DBOp::Delete { col, key } => writeln!(f, "  - {col} {}", to_base(key))?,
+                DBOp::Insert { col, key, .. } => writeln!(f, "  + {col} {}", to_base58(key))?,
+                DBOp::Set { col, key, .. } => writeln!(f, "  = {col} {}", to_base58(key))?,
+                DBOp::UpdateRefcount { col, key, .. } => {
+                    writeln!(f, "  ± {col} {}", to_base58(key))?
+                }
+                DBOp::Delete { col, key } => writeln!(f, "  - {col} {}", to_base58(key))?,
                 DBOp::DeleteAll { col } => writeln!(f, "  - {col} (all)")?,
             }
         }

integration-tests/src/user/rpc_user.rs

@@ -13,7 +13,7 @@ use near_jsonrpc_primitives::errors::ServerError;
 use near_jsonrpc_primitives::types::query::RpcQueryResponse;
 use near_primitives::hash::CryptoHash;
 use near_primitives::receipt::Receipt;
-use near_primitives::serialize::{to_base, to_base64};
+use near_primitives::serialize::{to_base58, to_base64};
 use near_primitives::transaction::SignedTransaction;
 use near_primitives::types::{
     AccountId, BlockHeight, BlockId, BlockReference, MaybeBlockId, ShardId,
@@ -51,7 +51,7 @@ impl RpcUser {
     }
 
     pub fn query(&self, path: String, data: &[u8]) -> Result<RpcQueryResponse, String> {
-        let data = to_base(data);
+        let data = to_base58(data);
         self.actix(move |client| client.query_by_path(path, data).map_err(|err| err.to_string()))
     }
 

nearcore/src/migrations.rs

@@ -68,14 +68,12 @@ mod tests {
     use near_mainnet_res::mainnet_restored_receipts;
     use near_mainnet_res::mainnet_storage_usage_delta;
     use near_primitives::hash::hash;
-    use near_primitives::serialize::to_base;
 
     #[test]
     fn test_migration_data() {
         assert_eq!(
-            to_base(&hash(
-                serde_json::to_string(&mainnet_storage_usage_delta()).unwrap().as_bytes()
-            )),
+            hash(serde_json::to_string(&mainnet_storage_usage_delta()).unwrap().as_bytes())
+                .to_string(),
             "2fEgaLFBBJZqgLQEvHPsck4NS3sFzsgyKaMDqTw5HVvQ"
         );
         let mainnet_migration_data = load_migration_data("mainnet");
@@ -87,7 +85,8 @@ mod tests {
     #[test]
     fn test_restored_receipts_data() {
         assert_eq!(
-            to_base(&hash(serde_json::to_string(&mainnet_restored_receipts()).unwrap().as_bytes())),
+            hash(serde_json::to_string(&mainnet_restored_receipts()).unwrap().as_bytes())
+                .to_string(),
             "48ZMJukN7RzvyJSW9MJ5XmyQkQFfjy2ZxPRaDMMHqUcT"
         );
         let mainnet_migration_data = load_migration_data("mainnet");

runtime/near-vm-logic/src/context.rs

@@ -14,7 +14,7 @@ pub struct VMContext {
     /// The account id of that signed the original transaction that led to this
     /// execution.
     pub signer_account_id: AccountId,
-    #[serde(with = "serialize::base_bytes_format")]
+    #[serde(with = "serialize::base58_format")]
     /// The public key that was used to sign the original transaction that led to
     /// this execution.
     pub signer_account_pk: PublicKey,
@@ -51,7 +51,7 @@ pub struct VMContext {
     pub attached_deposit: Balance,
     /// The gas attached to the call that can be used to pay for the gas fees.
     pub prepaid_gas: Gas,
-    #[serde(with = "serialize::base_bytes_format")]
+    #[serde(with = "serialize::base58_format")]
     /// Initial seed for randomness
     pub random_seed: Vec<u8>,
     /// If Some, it means that execution is made in a view mode and defines its configuration.

runtime/near-vm-logic/src/logic.rs

@@ -2348,7 +2348,7 @@ impl<'a> VMLogic<'a> {
 
         near_o11y::io_trace!(
             storage_op = "write",
-            key =  %near_primitives::serialize::to_base(key.clone()),
+            key = %near_primitives::serialize::to_base58(&key),
             size = value_len,
             evicted_len = evicted.as_ref().map(Vec::len),
             tn_mem_reads = nodes_delta.mem_reads,
@@ -2439,7 +2439,7 @@ impl<'a> VMLogic<'a> {
 
         near_o11y::io_trace!(
             storage_op = "read",
-            key =  %near_primitives::serialize::to_base(key.clone()),
+            key = %near_primitives::serialize::to_base58(&key),
             size = read.as_ref().map(Vec::len),
             tn_db_reads = nodes_delta.db_reads,
             tn_mem_reads = nodes_delta.mem_reads,
@@ -2499,7 +2499,7 @@ impl<'a> VMLogic<'a> {
 
         near_o11y::io_trace!(
             storage_op = "remove",
-            key =  %near_primitives::serialize::to_base(key.clone()),
+            key = %near_primitives::serialize::to_base58(&key),
             evicted_len = removed.as_ref().map(Vec::len),
             tn_mem_reads = nodes_delta.mem_reads,
             tn_db_reads = nodes_delta.db_reads,
@@ -2555,7 +2555,7 @@ impl<'a> VMLogic<'a> {
 
         near_o11y::io_trace!(
             storage_op = "exists",
-            key =  %near_primitives::serialize::to_base(key.clone()),
+            key = %near_primitives::serialize::to_base58(&key),
             tn_mem_reads = nodes_delta.mem_reads,
             tn_db_reads = nodes_delta.db_reads,
         );

tools/state-viewer/src/commands.rs

@@ -15,7 +15,6 @@ use near_network::iter_peers_from_store;
 use near_primitives::account::id::AccountId;
 use near_primitives::block::{Block, BlockHeader};
 use near_primitives::hash::CryptoHash;
-use near_primitives::serialize::to_base;
 use near_primitives::shard_layout::ShardUId;
 use near_primitives::sharding::ChunkHash;
 use near_primitives::state_record::StateRecord;
@@ -746,12 +745,12 @@ fn load_trie_stop_at_height(
     (runtime, state_roots, last_block.header().clone())
 }
 
-pub fn format_hash(h: CryptoHash, show_full_hashes: bool) -> String {
-    if show_full_hashes {
-        to_base(&h).to_string()
-    } else {
-        to_base(&h)[..7].to_string()
+fn format_hash(h: CryptoHash, show_full_hashes: bool) -> String {
+    let mut hash = h.to_string();
+    if !show_full_hashes {
+        hash.truncate(7);
     }
+    hash
 }
 
 pub fn chunk_mask_to_str(mask: &[bool]) -> String {