(wip) (fix) Fix Storage Usage

chain/chain/src/test_utils.rs

@@ -12,7 +12,8 @@ use tracing::debug;
 use near_chain_primitives::{Error, ErrorKind};
 use near_crypto::{KeyType, PublicKey, SecretKey, Signature};
 use near_pool::types::PoolIterator;
-use near_primitives::account::{AccessKey, Account};
+use near_primitives::access_key::AccessKey;
+use near_primitives::account::Account;
 use near_primitives::challenge::ChallengesResult;
 use near_primitives::epoch_manager::block_info::BlockInfo;
 use near_primitives::epoch_manager::epoch_info::EpochInfo;
@@ -807,6 +808,7 @@ impl RuntimeAdapter for KeyValueRuntime {
                         0,
                         CryptoHash::default(),
                         0,
+                        PROTOCOL_VERSION,
                     )
                     .into(),
                 ),

chain/rosetta-rpc/src/lib.rs

@@ -17,6 +17,8 @@ use near_primitives::borsh::BorshDeserialize;
 use near_primitives::serialize::BaseEncode;
 
 pub use config::RosettaRpcConfig;
+use near_primitives::version::PROTOCOL_VERSION;
+use near_primitives::views::AccountView;
 
 mod adapters;
 mod config;
@@ -376,7 +378,14 @@ async fn account_balance(
             Err(crate::errors::ErrorKind::NotFound(_)) => (
                 block.header.hash,
                 block.header.height,
-                near_primitives::account::Account::new(0, 0, Default::default(), 0).into(),
+                AccountView {
+                    amount: 0,
+                    locked: 0,
+                    code_hash: Default::default(),
+                    storage_usage: 0,
+                    storage_paid_at: 0,
+                }
+                .into(),
             ),
             Err(err) => return Err(err.into()),
         };

core/primitives-core/Cargo.toml

@@ -25,7 +25,6 @@ lazy_static = "1.4"
 [features]
 default = []
 costs_counting = []
-protocol_feature_add_account_versions = []
 protocol_feature_evm = []
 protocol_feature_alt_bn128 = []
 protocol_feature_tx_size_limit = []

core/primitives-core/src/access_key.rs

@@ -0,0 +1,70 @@
+use borsh::{BorshDeserialize, BorshSerialize};
+use serde::{Deserialize, Serialize};
+
+use crate::serialize::option_u128_dec_format;
+use crate::types::{AccountId, Balance, Nonce};
+
+/// Access key provides limited access to an account. Each access key belongs to some account and
+/// is identified by a unique (within the account) public key. One account may have large number of
+/// access keys. Access keys allow to act on behalf of the account by restricting transactions
+/// that can be issued.
+/// `account_id,public_key` is a key in the state
+#[derive(
+    BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Hash, Clone, Debug,
+)]
+pub struct AccessKey {
+    /// The nonce for this access key.
+    /// NOTE: In some cases the access key needs to be recreated. If the new access key reuses the
+    /// same public key, the nonce of the new access key should be equal to the nonce of the old
+    /// access key. It's required to avoid replaying old transactions again.
+    pub nonce: Nonce,
+
+    /// Defines permissions for this access key.
+    pub permission: AccessKeyPermission,
+}
+
+impl AccessKey {
+    pub const ACCESS_KEY_NONCE_RANGE_MULTIPLIER: u64 = 1_000_000;
+
+    pub fn full_access() -> Self {
+        Self { nonce: 0, permission: AccessKeyPermission::FullAccess }
+    }
+}
+
+/// Defines permissions for AccessKey
+#[derive(
+    BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Hash, Clone, Debug,
+)]
+pub enum AccessKeyPermission {
+    FunctionCall(FunctionCallPermission),
+
+    /// Grants full access to the account.
+    /// NOTE: It's used to replace account-level public keys.
+    FullAccess,
+}
+
+/// Grants limited permission to make transactions with FunctionCallActions
+/// The permission can limit the allowed balance to be spent on the prepaid gas.
+/// It also restrict the account ID of the receiver for this function call.
+/// It also can restrict the method name for the allowed function calls.
+#[derive(
+    BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Hash, Clone, Debug,
+)]
+pub struct FunctionCallPermission {
+    /// Allowance is a balance limit to use by this access key to pay for function call gas and
+    /// transaction fees. When this access key is used, both account balance and the allowance is
+    /// decreased by the same value.
+    /// `None` means unlimited allowance.
+    /// NOTE: To change or increase the allowance, the old access key needs to be deleted and a new
+    /// access key should be created.
+    #[serde(with = "option_u128_dec_format")]
+    pub allowance: Option<Balance>,
+
+    /// The access key only allows transactions with the given receiver's account id.
+    pub receiver_id: AccountId,
+
+    /// A list of method names that can be used. The access key only allows transactions with the
+    /// function call of one of the given method names.
+    /// Empty list means any method name can be used.
+    pub method_names: Vec<String>,
+}

core/primitives-core/src/lib.rs

@@ -1,7 +1,7 @@
 pub use borsh;
 pub use num_rational;
 
-pub mod account;
+pub mod access_key;
 pub mod config;
 pub mod contract;
 pub mod hash;

core/primitives/Cargo.toml

@@ -43,7 +43,7 @@ default = ["jemallocator", "stable_protocol_features"]
 dump_errors_schema = ["near-rpc-error-macro/dump_errors_schema"]
 stable_protocol_features = ["protocol_feature_lower_storage_cost"]
 protocol_feature_lower_storage_cost = []
-protocol_feature_add_account_versions = ["near-primitives-core/protocol_feature_add_account_versions"]
+protocol_feature_add_account_versions = []
 protocol_feature_forward_chunk_parts = []
 protocol_feature_rectify_inflation = []
 protocol_feature_evm = ["near-primitives-core/protocol_feature_evm"]

core/primitives-core/src/account.rs → core/primitives/src/account.rs

@@ -1,9 +1,17 @@
+#[cfg(feature = "protocol_feature_add_account_versions")]
+use crate::checked_feature;
+use crate::serialize::u128_dec_format_compatible;
 use borsh::{BorshDeserialize, BorshSerialize};
+#[cfg(feature = "protocol_feature_add_account_versions")]
+use core::default::Default;
+#[cfg(feature = "protocol_feature_add_account_versions")]
+use core::result::Result;
+#[cfg(feature = "protocol_feature_add_account_versions")]
+use core::result::Result::Ok;
+use near_primitives_core::hash::CryptoHash;
+use near_primitives_core::types::{Balance, ProtocolVersion, StorageUsage};
+use serde;
 use serde::{Deserialize, Serialize};
-
-use crate::hash::CryptoHash;
-use crate::serialize::{option_u128_dec_format, u128_dec_format_compatible};
-use crate::types::{AccountId, Balance, Nonce, StorageUsage};
 #[cfg(feature = "protocol_feature_add_account_versions")]
 use std::io;
 
@@ -12,7 +20,11 @@ use std::io;
     BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Debug, Clone, Copy,
 )]
 pub enum AccountVersion {
+    /// Versioning release
     V1,
+    /// Recalculated storage usage due to previous bug, see
+    /// https://github.com/near/nearcore/issues/3824
+    V2,
 }
 
 #[cfg(feature = "protocol_feature_add_account_versions")]
@@ -55,14 +67,25 @@ impl Account {
         locked: Balance,
         code_hash: CryptoHash,
         storage_usage: StorageUsage,
+        protocol_version: ProtocolVersion,
     ) -> Self {
-        Account {
+        #[cfg(not(feature = "protocol_feature_add_account_versions"))]
+        let _ = protocol_version;
+        Self {
             amount,
             locked,
             code_hash,
             storage_usage,
             #[cfg(feature = "protocol_feature_add_account_versions")]
-            version: AccountVersion::V1,
+            version: if checked_feature!(
+                "protocol_feature_add_account_versions",
+                AccountVersions,
+                protocol_version
+            ) {
+                AccountVersion::V2
+            } else {
+                AccountVersion::V1
+            },
         }
     }
 
@@ -128,6 +151,16 @@ struct LegacyAccount {
     storage_usage: StorageUsage,
 }
 
+#[cfg(feature = "protocol_feature_add_account_versions")]
+#[derive(BorshSerialize, BorshDeserialize)]
+struct SerializableAccount {
+    amount: Balance,
+    locked: Balance,
+    code_hash: CryptoHash,
+    storage_usage: StorageUsage,
+    version: AccountVersion,
+}
+
 #[cfg(feature = "protocol_feature_add_account_versions")]
 impl BorshDeserialize for Account {
     fn deserialize(buf: &mut &[u8]) -> Result<Self, io::Error> {
@@ -143,7 +176,14 @@ impl BorshDeserialize for Account {
                 version: AccountVersion::V1,
             })
         } else {
-            unreachable!();
+            let deserialized_account = SerializableAccount::deserialize(buf)?;
+            Ok(Account {
+                amount: deserialized_account.amount,
+                locked: deserialized_account.locked,
+                code_hash: deserialized_account.code_hash,
+                storage_usage: deserialized_account.storage_usage,
+                version: deserialized_account.version,
+            })
         }
     }
 }
@@ -159,91 +199,73 @@ impl BorshSerialize for Account {
                 storage_usage: self.storage_usage,
             }
             .serialize(writer),
+            _ => SerializableAccount {
+                amount: self.amount,
+                locked: self.locked,
+                code_hash: self.code_hash,
+                storage_usage: self.storage_usage,
+                version: self.version,
+            }
+            .serialize(writer),
         }
     }
 }
 
-/// Access key provides limited access to an account. Each access key belongs to some account and
-/// is identified by a unique (within the account) public key. One account may have large number of
-/// access keys. Access keys allow to act on behalf of the account by restricting transactions
-/// that can be issued.
-/// `account_id,public_key` is a key in the state
-#[derive(
-    BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Hash, Clone, Debug,
-)]
-pub struct AccessKey {
-    /// The nonce for this access key.
-    /// NOTE: In some cases the access key needs to be recreated. If the new access key reuses the
-    /// same public key, the nonce of the new access key should be equal to the nonce of the old
-    /// access key. It's required to avoid replaying old transactions again.
-    pub nonce: Nonce,
-
-    /// Defines permissions for this access key.
-    pub permission: AccessKeyPermission,
-}
-
-impl AccessKey {
-    pub const ACCESS_KEY_NONCE_RANGE_MULTIPLIER: u64 = 1_000_000;
-
-    pub fn full_access() -> Self {
-        Self { nonce: 0, permission: AccessKeyPermission::FullAccess }
-    }
-}
-
-/// Defines permissions for AccessKey
-#[derive(
-    BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Hash, Clone, Debug,
-)]
-pub enum AccessKeyPermission {
-    FunctionCall(FunctionCallPermission),
-
-    /// Grants full access to the account.
-    /// NOTE: It's used to replace account-level public keys.
-    FullAccess,
-}
-
-/// Grants limited permission to make transactions with FunctionCallActions
-/// The permission can limit the allowed balance to be spent on the prepaid gas.
-/// It also restrict the account ID of the receiver for this function call.
-/// It also can restrict the method name for the allowed function calls.
-#[derive(
-    BorshSerialize, BorshDeserialize, Serialize, Deserialize, PartialEq, Eq, Hash, Clone, Debug,
-)]
-pub struct FunctionCallPermission {
-    /// Allowance is a balance limit to use by this access key to pay for function call gas and
-    /// transaction fees. When this access key is used, both account balance and the allowance is
-    /// decreased by the same value.
-    /// `None` means unlimited allowance.
-    /// NOTE: To change or increase the allowance, the old access key needs to be deleted and a new
-    /// access key should be created.
-    #[serde(with = "option_u128_dec_format")]
-    pub allowance: Option<Balance>,
-
-    /// The access key only allows transactions with the given receiver's account id.
-    pub receiver_id: AccountId,
-
-    /// A list of method names that can be used. The access key only allows transactions with the
-    /// function call of one of the given method names.
-    /// Empty list means any method name can be used.
-    pub method_names: Vec<String>,
-}
-
 #[cfg(test)]
 mod tests {
+    use crate::account::Account;
+    #[cfg(feature = "protocol_feature_add_account_versions")]
+    use crate::account::{AccountVersion, LegacyAccount};
+    #[cfg(feature = "protocol_feature_add_account_versions")]
+    use crate::borsh::BorshDeserialize;
+    use crate::hash::CryptoHash;
+    #[cfg(feature = "protocol_feature_add_account_versions")]
+    use crate::version::ProtocolFeature;
+    #[cfg(not(feature = "protocol_feature_add_account_versions"))]
+    use crate::version::PROTOCOL_VERSION;
     use borsh::BorshSerialize;
-
-    use crate::hash::hash;
-    use crate::serialize::to_base;
-
-    use super::*;
+    use near_primitives_core::hash::hash;
+    use near_primitives_core::serialize::to_base;
 
     #[test]
     fn test_account_serialization() {
-        let acc = Account::new(1_000_000, 1_000_000, CryptoHash::default(), 100);
+        #[cfg(feature = "protocol_feature_add_account_versions")]
+        let acc = Account::new(
+            1_000_000,
+            1_000_000,
+            CryptoHash::default(),
+            100,
+            ProtocolFeature::AccountVersions.protocol_version() - 1,
+        );
+        #[cfg(not(feature = "protocol_feature_add_account_versions"))]
+        let acc = Account::new(1_000_000, 1_000_000, CryptoHash::default(), 100, PROTOCOL_VERSION);
         let bytes = acc.try_to_vec().unwrap();
         assert_eq!(to_base(&hash(&bytes)), "EVk5UaxBe8LQ8r8iD5EAxVBs6TJcMDKqyH7PBuho6bBJ");
     }
 
+    #[test]
+    #[cfg(feature = "protocol_feature_add_account_versions")]
+    fn test_account_size() {
+        let new_account = Account::new(
+            0,
+            0,
+            CryptoHash::default(),
+            0,
+            ProtocolFeature::AccountVersions.protocol_version(),
+        );
+        let old_account = Account::new(
+            0,
+            0,
+            CryptoHash::default(),
+            0,
+            ProtocolFeature::AccountVersions.protocol_version() - 1,
+        );
+        let new_bytes = new_account.try_to_vec().unwrap();
+        let old_bytes = old_account.try_to_vec().unwrap();
+        assert!(new_bytes.len() > old_bytes.len());
+        assert_eq!(old_bytes.len(), std::mem::size_of::<LegacyAccount>());
+    }
+
     #[test]
     #[cfg(feature = "protocol_feature_add_account_versions")]
     fn test_account_deserialization() {

core/primitives/src/lib.rs

@@ -1,7 +1,8 @@
 pub use near_primitives_core::borsh;
 pub use near_primitives_core::num_rational;
 
-pub use near_primitives_core::account;
+pub use near_primitives_core::access_key;
+pub mod account;
 pub mod block;
 pub mod block_header;
 pub mod challenge;

core/primitives/src/state_record.rs

@@ -4,7 +4,8 @@ use std::fmt::{Display, Formatter};
 
 use near_crypto::PublicKey;
 
-use crate::account::{AccessKey, Account};
+use crate::access_key::AccessKey;
+use crate::account::Account;
 use crate::hash::{hash, CryptoHash};
 use crate::receipt::{Receipt, ReceivedData};
 use crate::serialize::{base64_format, option_base64_format};