[NEP-491] Non-refundable storage

chain/chain/src/test_utils/kv_runtime.rs

@@ -1239,6 +1239,7 @@ impl RuntimeAdapter for KeyValueRuntime {
                             |state| *state.amounts.get(account_id).unwrap_or(&0),
                         ),
                         0,
+                        0,
                         CryptoHash::default(),
                         0,
                     )

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, @"B1hfhfWYpKi4KZXVv63nQyUgezLuBXXppShMxK16vZ5X");
+        insta::assert_display_snapshot!(hash, @"4tEtbSAU6GgB4wdDfgdzhPm3H7fd5cyWtzFFiYo7kopi");
     } else {
         insta::assert_display_snapshot!(hash, @"HbQVGVZ3WGxsNqeM3GfSwDoxwYZ2RBP1SinAze9SYR3C");
     }

chain/client/src/test_utils/test_env.rs

@@ -7,6 +7,7 @@ use crate::Client;
 use near_async::messaging::CanSend;
 use near_chain::test_utils::ValidatorSchedule;
 use near_chain::{ChainGenesis, Provenance};
+use near_chain_primitives::error::QueryError;
 use near_chunks::client::ShardsManagerResponse;
 use near_chunks::test_utils::MockClientAdapterForShardsManager;
 use near_crypto::{InMemorySigner, KeyType, Signer};
@@ -30,8 +31,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, ShardsManagerAdapterForTest};
@@ -425,6 +428,22 @@ impl TestEnv {
         }
     }
 
+    /// 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

@@ -2,6 +2,7 @@ use actix::Addr;
 use near_chain_configs::Genesis;
 use near_client::ViewClientActor;
 use near_o11y::WithSpanContextExt;
+use near_primitives::transaction::TransferAction;
 use validated_operations::ValidatedOperation;
 
 pub(crate) mod nep141;
@@ -325,7 +326,36 @@ impl From<NearActions> for Vec<crate::models::Operation> {
                     );
                 }
 
-                near_primitives::transaction::Action::Transfer(action) => {
+                near_primitives::transaction::Action::Transfer(TransferAction { deposit }) => {
+                    let transfer_amount = crate::models::Amount::from_yoctonear(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],
+                        ),
+                    );
+                }
+
+                #[cfg(feature = "protocol_feature_nonrefundable_transfer_nep491")]
+                // Note(jakmeier): Both refundable and non-refundable transfers are considered as available balance.
+                near_primitives::transaction::Action::NonrefundableStorageTransfer(action) => {
                     let transfer_amount = crate::models::Amount::from_yoctonear(action.deposit);
 
                     let sender_transfer_operation_id =
@@ -860,6 +890,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 +907,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 +922,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 +939,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 +954,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 +966,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/adapters/transactions.rs

@@ -309,9 +309,9 @@ pub(crate) async fn convert_block_changes_to_transactions(
                             .actions
                             .iter()
                             .map(|action| match action {
-                                near_primitives::views::ActionView::Transfer { deposit } => {
-                                    *deposit
-                                }
+                                near_primitives::views::ActionView::Transfer {
+                                    deposit, ..
+                                } => *deposit,
                                 _ => 0,
                             })
                             .sum::<u128>();

chain/rosetta-rpc/src/lib.rs

@@ -368,7 +368,7 @@ 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).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());
@@ -204,7 +204,7 @@ mod test {
     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)
     }
 
     #[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",
 ]