[NEP-491] Non-refundable storage

chain/chain/src/test_utils/kv_runtime.rs

@@ -1242,8 +1242,10 @@ impl RuntimeAdapter for KeyValueRuntime {
                             |state| *state.amounts.get(account_id).unwrap_or(&0),
                         ),
                         0,
+                        0,
                         CryptoHash::default(),
                         0,
+                        PROTOCOL_VERSION,
                     )
                     .into(),
                 ),

chain/chain/src/tests/simple_chain.rs

@@ -52,7 +52,7 @@ fn build_chain() {
     //     cargo insta test --accept -p near-chain --features nightly -- tests::simple_chain::build_chain
     let hash = chain.head().unwrap().last_block_hash;
     if cfg!(feature = "nightly") {
-        insta::assert_display_snapshot!(hash, @"DyeyWKAniYDFcxkf3n1VZdZfckguyvNs4qwoETYW2ofW");
+        insta::assert_display_snapshot!(hash, @"9JRdRkSfVRwYBVFNzfKwuhuUabMkQN14b1Ge7z1FRnMF");
     } else {
         insta::assert_display_snapshot!(hash, @"HJmRPXT4JM9tt6mXw2gM75YaSoqeDCphhFK26uRpd1vw");
     }
@@ -82,7 +82,7 @@ fn build_chain() {
 
     let hash = chain.head().unwrap().last_block_hash;
     if cfg!(feature = "nightly") {
-        insta::assert_display_snapshot!(hash, @"NuKEKpsFRb3ZwTe9TtEuQcK1qkPKRBvkv8cNd9GrzN2");
+        insta::assert_display_snapshot!(hash, @"HkPEDHWJHuW8Yzw9FonrJarVAHi51mQt7A4DQUtBagko");
     } else {
         insta::assert_display_snapshot!(hash, @"HbQVGVZ3WGxsNqeM3GfSwDoxwYZ2RBP1SinAze9SYR3C");
     }

chain/client/src/test_utils/test_env.rs

@@ -12,6 +12,7 @@ use near_async::time::Clock;
 use near_chain::test_utils::ValidatorSchedule;
 use near_chain::{ChainGenesis, Provenance};
 use near_chain_configs::GenesisConfig;
+use near_chain_primitives::error::QueryError;
 use near_chunks::client::ShardsManagerResponse;
 use near_chunks::test_utils::{MockClientAdapterForShardsManager, SynchronousShardsManagerAdapter};
 use near_crypto::{InMemorySigner, KeyType, Signer};
@@ -36,8 +37,10 @@ use near_primitives::types::{AccountId, Balance, BlockHeight, EpochId, NumSeats}
 use near_primitives::utils::MaybeValidated;
 use near_primitives::version::ProtocolVersion;
 use near_primitives::views::{
-    AccountView, FinalExecutionOutcomeView, QueryRequest, QueryResponseKind, StateItem,
+    AccountView, FinalExecutionOutcomeView, QueryRequest, QueryResponse, QueryResponseKind,
+    StateItem,
 };
+use near_store::ShardUId;
 use once_cell::sync::OnceCell;
 
 use super::setup::setup_client_with_runtime;
@@ -462,6 +465,22 @@ impl TestEnv {
         panic!("No client tracks shard {}", shard_id);
     }
 
+    /// Passes the given query to the runtime adapter using the current head and returns a result.
+    pub fn query_view(&mut self, request: QueryRequest) -> Result<QueryResponse, QueryError> {
+        let head = self.clients[0].chain.head().unwrap();
+        let head_block = self.clients[0].chain.get_block(&head.last_block_hash).unwrap();
+        self.clients[0].runtime_adapter.query(
+            ShardUId::single_shard(),
+            &head_block.chunks()[0].prev_state_root(),
+            head.height,
+            0,
+            &head.prev_block_hash,
+            &head.last_block_hash,
+            head_block.header().epoch_id(),
+            &request,
+        )
+    }
+
     pub fn query_state(&mut self, account_id: AccountId) -> Vec<StateItem> {
         let client = &self.clients[0];
         let head = client.chain.head().unwrap();

chain/jsonrpc/res/rpc_errors_schema.json

@@ -46,7 +46,8 @@
         "DelegateActionExpired",
         "DelegateActionAccessKeyError",
         "DelegateActionInvalidNonce",
-        "DelegateActionNonceTooLarge"
+        "DelegateActionNonceTooLarge",
+        "NonRefundableBalanceToExistingAccount"
       ],
       "props": {
         "index": ""
@@ -640,6 +641,13 @@
       "subtypes": [],
       "props": {}
     },
+    "NonRefundableBalanceToExistingAccount": {
+      "name": "NonRefundableBalanceToExistingAccount",
+      "subtypes": [],
+      "props": {
+        "account_id": ""
+      }
+    },
     "NonceTooLarge": {
       "name": "NonceTooLarge",
       "subtypes": [],

chain/rosetta-rpc/Cargo.toml

@@ -43,6 +43,7 @@ insta.workspace = true
 near-actix-test-utils.workspace = true
 
 [features]
+protocol_feature_nonrefundable_transfer_nep491 = []
 nightly_protocol = [
   "near-actix-test-utils/nightly_protocol",
   "near-chain-configs/nightly_protocol",
@@ -65,4 +66,5 @@ nightly = [
   "near-primitives/nightly",
   "nightly_protocol",
   "node-runtime/nightly",
+  "protocol_feature_nonrefundable_transfer_nep491",
 ]

chain/rosetta-rpc/src/adapters/mod.rs

@@ -352,6 +352,36 @@ impl From<NearActions> for Vec<crate::models::Operation> {
                     );
                 }
 
+                #[cfg(feature = "protocol_feature_nonrefundable_transfer_nep491")]
+                // Both refundable and non-refundable transfers are considered as available balance.
+                // TODO(nonrefundable) Merge with the arm above on stabilization.
+                near_primitives::transaction::Action::NonrefundableStorageTransfer(action) => {
+                    let transfer_amount = crate::models::Amount::from_yoctonear(action.deposit);
+
+                    let sender_transfer_operation_id =
+                        crate::models::OperationIdentifier::new(&operations);
+                    operations.push(
+                        validated_operations::TransferOperation {
+                            account: sender_account_identifier.clone(),
+                            amount: -transfer_amount.clone(),
+                            predecessor_id: Some(sender_account_identifier.clone()),
+                        }
+                        .into_operation(sender_transfer_operation_id.clone()),
+                    );
+
+                    operations.push(
+                        validated_operations::TransferOperation {
+                            account: receiver_account_identifier.clone(),
+                            amount: transfer_amount,
+                            predecessor_id: Some(sender_account_identifier.clone()),
+                        }
+                        .into_related_operation(
+                            crate::models::OperationIdentifier::new(&operations),
+                            vec![sender_transfer_operation_id],
+                        ),
+                    );
+                }
+
                 near_primitives::transaction::Action::Stake(action) => {
                     operations.push(
                         validated_operations::StakeOperation {
@@ -837,6 +867,35 @@ mod tests {
     use near_primitives::action::delegate::{DelegateAction, SignedDelegateAction};
     use near_primitives::transaction::{Action, TransferAction};
 
+    #[cfg(feature = "protocol_feature_nonrefundable_transfer_nep491")]
+    #[test]
+    fn test_convert_nonrefundable_storage_transfer_action() {
+        let transfer_actions = vec![near_primitives::transaction::TransferAction {
+            deposit: near_primitives::types::Balance::MAX,
+        }
+        .into()];
+        let nonrefundable_transfer_actions =
+            vec![near_primitives::transaction::NonrefundableStorageTransferAction {
+                deposit: near_primitives::types::Balance::MAX,
+            }
+            .into()];
+        let near_transfer_actions = NearActions {
+            sender_account_id: "sender.near".parse().unwrap(),
+            receiver_account_id: "receiver.near".parse().unwrap(),
+            actions: transfer_actions,
+        };
+        let near_nonrefundable_transfer_actions = NearActions {
+            sender_account_id: "sender.near".parse().unwrap(),
+            receiver_account_id: "receiver.near".parse().unwrap(),
+            actions: nonrefundable_transfer_actions,
+        };
+        let transfer_operations_converted: Vec<crate::models::Operation> =
+            near_transfer_actions.into();
+        let nonrefundable_transfer_operations_converted: Vec<crate::models::Operation> =
+            near_nonrefundable_transfer_actions.into();
+        assert_eq!(transfer_operations_converted, nonrefundable_transfer_operations_converted);
+    }
+
     #[test]
     fn test_convert_block_changes_to_transactions() {
         run_actix(async {
@@ -860,6 +919,8 @@ mod tests {
                             amount: 5000000000000000000,
                             code_hash: near_primitives::hash::CryptoHash::default(),
                             locked: 400000000000000000000000000000,
+                            #[cfg(feature = "protocol_feature_nonrefundable_transfer_nep491")]
+                            nonrefundable: 0,
                             storage_paid_at: 0,
                             storage_usage: 200000,
                         },
@@ -875,6 +936,8 @@ mod tests {
                             amount: 4000000000000000000,
                             code_hash: near_primitives::hash::CryptoHash::default(),
                             locked: 400000000000000000000000000000,
+                            #[cfg(feature = "protocol_feature_nonrefundable_transfer_nep491")]
+                            nonrefundable: 0,
                             storage_paid_at: 0,
                             storage_usage: 200000,
                         },
@@ -888,6 +951,8 @@ mod tests {
                             amount: 7000000000000000000,
                             code_hash: near_primitives::hash::CryptoHash::default(),
                             locked: 400000000000000000000000000000,
+                            #[cfg(feature = "protocol_feature_nonrefundable_transfer_nep491")]
+                            nonrefundable: 0,
                             storage_paid_at: 0,
                             storage_usage: 200000,
                         },
@@ -903,6 +968,8 @@ mod tests {
                             amount: 8000000000000000000,
                             code_hash: near_primitives::hash::CryptoHash::default(),
                             locked: 400000000000000000000000000000,
+                            #[cfg(feature = "protocol_feature_nonrefundable_transfer_nep491")]
+                            nonrefundable: 0,
                             storage_paid_at: 0,
                             storage_usage: 200000,
                         },
@@ -916,6 +983,8 @@ mod tests {
                     amount: 4000000000000000000,
                     code_hash: near_primitives::hash::CryptoHash::default(),
                     locked: 400000000000000000000000000000,
+                    #[cfg(feature = "protocol_feature_nonrefundable_transfer_nep491")]
+                    nonrefundable: 0,
                     storage_paid_at: 0,
                     storage_usage: 200000,
                 },
@@ -926,6 +995,8 @@ mod tests {
                     amount: 6000000000000000000,
                     code_hash: near_primitives::hash::CryptoHash::default(),
                     locked: 400000000000000000000000000000,
+                    #[cfg(feature = "protocol_feature_nonrefundable_transfer_nep491")]
+                    nonrefundable: 0,
                     storage_paid_at: 0,
                     storage_usage: 200000,
                 },

chain/rosetta-rpc/src/lib.rs

@@ -17,7 +17,7 @@ pub use config::RosettaRpcConfig;
 use near_chain_configs::Genesis;
 use near_client::{ClientActor, ViewClientActor};
 use near_o11y::WithSpanContextExt;
-use near_primitives::borsh::BorshDeserialize;
+use near_primitives::{borsh::BorshDeserialize, version::PROTOCOL_VERSION};
 
 mod adapters;
 mod config;
@@ -368,7 +368,15 @@ 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(),
+                near_primitives::account::Account::new(
+                    0,
+                    0,
+                    0,
+                    Default::default(),
+                    0,
+                    PROTOCOL_VERSION,
+                )
+                .into(),
             ),
             Err(err) => return Err(err.into()),
         };

core/chain-configs/src/genesis_validate.rs

@@ -58,7 +58,7 @@ impl<'a> GenesisValidator<'a> {
                         format!("Duplicate account id {} in genesis records", account_id);
                     self.validation_errors.push_genesis_semantics_error(error_message)
                 }
-                self.total_supply += account.locked() + account.amount();
+                self.total_supply += account.locked() + account.amount() + account.nonrefundable();
                 self.account_ids.insert(account_id.clone());
                 if account.locked() > 0 {
                     self.staked_accounts.insert(account_id.clone(), account.locked());
@@ -200,11 +200,31 @@ mod test {
     use near_crypto::{KeyType, PublicKey};
     use near_primitives::account::{AccessKey, Account};
     use near_primitives::types::AccountInfo;
+    use near_primitives::version::PROTOCOL_VERSION;
 
     const VALID_ED25519_RISTRETTO_KEY: &str = "ed25519:KuTCtARNzxZQ3YvXDeLjx83FDqxv2SdQTSbiq876zR7";
 
     fn create_account() -> Account {
-        Account::new(100, 10, Default::default(), 0)
+        Account::new(100, 10, 0, Default::default(), 0, PROTOCOL_VERSION)
+    }
+
+    #[cfg(feature = "protocol_feature_nonrefundable_transfer_nep491")]
+    #[test]
+    fn test_total_supply_includes_nonrefundable_amount() {
+        let mut config = GenesisConfig::default();
+        config.epoch_length = 42;
+        config.total_supply = 111;
+        config.validators = vec![AccountInfo {
+            account_id: "test".parse().unwrap(),
+            public_key: VALID_ED25519_RISTRETTO_KEY.parse().unwrap(),
+            amount: 10,
+        }];
+        let records = GenesisRecords(vec![StateRecord::Account {
+            account_id: "test".parse().unwrap(),
+            account: Account::new(100, 10, 1, Default::default(), 0, PROTOCOL_VERSION),
+        }]);
+        let genesis = &Genesis::new(config, records).unwrap();
+        validate_genesis(genesis).unwrap();
     }
 
     #[test]

core/primitives-core/Cargo.toml

@@ -29,17 +29,20 @@ near-account-id.workspace = true
 [dev-dependencies]
 serde_json.workspace = true
 insta.workspace = true
+expect-test.workspace = true
 
 [features]
 default = []
 protocol_feature_fix_staking_threshold = []
 protocol_feature_fix_contract_loading_cost = []
 protocol_feature_reject_blocks_with_outdated_protocol_version = []
+protocol_feature_nonrefundable_transfer_nep491 = []
 
 nightly = [
   "nightly_protocol",
   "protocol_feature_fix_contract_loading_cost",
   "protocol_feature_fix_staking_threshold",
+  "protocol_feature_nonrefundable_transfer_nep491",
   "protocol_feature_reject_blocks_with_outdated_protocol_version",
 ]