Introduce priority fee field for transaction and receipt

chain/chain/src/chain.rs

@@ -3011,7 +3011,7 @@ impl Chain {
                 self.chain_store()
                     .check_transaction_validity_period(
                         prev_block_header,
-                        &transaction.transaction.block_hash,
+                        transaction.transaction.block_hash(),
                         transaction_validity_period,
                     )
                     .map_err(|_| Error::from(Error::InvalidTransactions))?;
@@ -3029,7 +3029,7 @@ impl Chain {
             self.chain_store()
                 .check_transaction_validity_period(
                     &prev_block_header,
-                    &tx.transaction.block_hash,
+                    tx.transaction.block_hash(),
                     self.transaction_validity_period,
                 )
                 .is_ok()
@@ -4406,7 +4406,7 @@ impl Chain {
     ) -> HashMap<ShardId, Vec<Receipt>> {
         let mut result = HashMap::new();
         for receipt in receipts {
-            let shard_id = account_id_to_shard_id(&receipt.receiver_id, shard_layout);
+            let shard_id = account_id_to_shard_id(receipt.receiver_id(), shard_layout);
             let entry = result.entry(shard_id).or_insert_with(Vec::new);
             entry.push(receipt)
         }
@@ -4427,8 +4427,8 @@ impl Chain {
         let mut cache = HashMap::new();
         for receipt in receipts {
             let &mut shard_id = cache
-                .entry(&receipt.receiver_id)
-                .or_insert_with(|| account_id_to_shard_id(&receipt.receiver_id, shard_layout));
+                .entry(receipt.receiver_id())
+                .or_insert_with(|| account_id_to_shard_id(receipt.receiver_id(), shard_layout));
             // This unwrap should be safe as we pre-populated the map with all
             // valid shard ids.
             result.get_mut(&shard_id).unwrap().push(receipt);

chain/chain/src/chain_update.rs

@@ -137,7 +137,10 @@ impl<'a> ChainUpdate<'a> {
         let outgoing_receipts = outgoing_receipts
             .iter()
             .map(|receipt| {
-                (receipt.receipt_id, account_id_to_shard_id(&receipt.receiver_id, &shard_layout))
+                (
+                    *receipt.receipt_id(),
+                    account_id_to_shard_id(receipt.receiver_id(), &shard_layout),
+                )
             })
             .collect();
         Ok(outgoing_receipts)

chain/chain/src/garbage_collection.rs

@@ -876,10 +876,9 @@ impl<'a> ChainStoreUpdate<'a> {
 
     fn gc_outgoing_receipts(&mut self, block_hash: &CryptoHash, shard_id: ShardId) {
         let mut store_update = self.store().store_update();
-        match self
-            .get_outgoing_receipts(block_hash, shard_id)
-            .map(|receipts| receipts.iter().map(|receipt| receipt.receipt_id).collect::<Vec<_>>())
-        {
+        match self.get_outgoing_receipts(block_hash, shard_id).map(|receipts| {
+            receipts.iter().map(|receipt| *receipt.receipt_id()).collect::<Vec<_>>()
+        }) {
             Ok(receipt_ids) => {
                 for receipt_id in receipt_ids {
                     let key: Vec<u8> = receipt_id.into();

chain/chain/src/runtime/mod.rs

@@ -650,7 +650,7 @@ impl RuntimeAdapter for NightshadeRuntime {
 
         if let Some(state_root) = state_root {
             let shard_uid =
-                self.account_id_to_shard_uid(&transaction.transaction.signer_id, epoch_id)?;
+                self.account_id_to_shard_uid(transaction.transaction.signer_id(), epoch_id)?;
             let mut state_update = self.tries.new_trie_update(shard_uid, state_root);
 
             match verify_and_charge_transaction(
@@ -825,7 +825,7 @@ impl RuntimeAdapter for NightshadeRuntime {
                     if ProtocolFeature::CongestionControl.enabled(protocol_version) {
                         let receiving_shard = EpochManagerAdapter::account_id_to_shard_id(
                             self.epoch_manager.as_ref(),
-                            &tx.transaction.receiver_id,
+                            tx.transaction.receiver_id(),
                             &epoch_id,
                         )?;
                         if let Some(shard_congestion) =

chain/chain/src/runtime/tests.rs

@@ -59,6 +59,7 @@ fn stake(
         vec![Action::Stake(Box::new(StakeAction { stake, public_key: sender.public_key() }))],
         // runtime does not validate block history
         CryptoHash::default(),
+        0,
     )
 }
 
@@ -355,7 +356,7 @@ impl TestEnv {
         let shard_layout = self.epoch_manager.get_shard_layout_from_prev_block(&new_hash).unwrap();
         let mut new_receipts = HashMap::<_, Vec<Receipt>>::new();
         for receipt in all_receipts {
-            let shard_id = account_id_to_shard_id(&receipt.receiver_id, &shard_layout);
+            let shard_id = account_id_to_shard_id(receipt.receiver_id(), &shard_layout);
             new_receipts.entry(shard_id).or_default().push(receipt);
         }
         self.last_receipts = new_receipts;
@@ -1389,6 +1390,7 @@ fn test_delete_account_after_unstake() {
         })],
         // runtime does not validate block history
         CryptoHash::default(),
+        0,
     );
     env.step_default(vec![delete_account_transaction]);
     for _ in 15..=17 {
@@ -1480,6 +1482,7 @@ fn test_trie_and_flat_state_equality() {
         vec![Action::Transfer(TransferAction { deposit: 10 })],
         // runtime does not validate block history
         CryptoHash::default(),
+        0,
     );
     env.step_default(vec![transfer_tx]);
     for _ in 1..=5 {
@@ -1650,7 +1653,7 @@ fn prepare_transactions(
                 .chain_store()
                 .check_transaction_validity_period(
                     &chain.get_block_header(&env.head.prev_block_hash).unwrap(),
-                    &tx.transaction.block_hash,
+                    tx.transaction.block_hash(),
                     chain.transaction_validity_period,
                 )
                 .is_ok()

chain/chain/src/store/mod.rs

@@ -383,12 +383,12 @@ fn filter_incoming_receipts_for_shard(
         let ReceiptProof(receipts, shard_proof) = receipt_proof.clone();
         for receipt in receipts {
             let receiver_shard_id =
-                account_id_to_shard_id(&receipt.receiver_id, target_shard_layout);
+                account_id_to_shard_id(receipt.receiver_id(), target_shard_layout);
             if receiver_shard_id == target_shard_id {
-                tracing::trace!(target: "chain", receipt_id=?receipt.receipt_id, "including receipt");
+                tracing::trace!(target: "chain", receipt_id=?receipt.receipt_id(), "including receipt");
                 filtered_receipts.push(receipt);
             } else {
-                tracing::trace!(target: "chain", receipt_id=?receipt.receipt_id, "excluding receipt");
+                tracing::trace!(target: "chain", receipt_id=?receipt.receipt_id(), "excluding receipt");
             }
         }
         // TODO(resharding) adjust the shard proof accordingly
@@ -689,7 +689,7 @@ impl ChainStore {
         shard_id: ShardId,
     ) -> Result<(), Error> {
         receipts.retain(|receipt| {
-            account_id_to_shard_id(&receipt.receiver_id, &shard_layout) == shard_id
+            account_id_to_shard_id(receipt.receiver_id(), &shard_layout) == shard_id
         });
         Ok(())
     }
@@ -1977,7 +1977,7 @@ impl<'a> ChainStoreUpdate<'a> {
         for receipt in chunk.prev_outgoing_receipts() {
             self.chain_store_cache_update
                 .receipts
-                .insert(receipt.receipt_id, Arc::new(receipt.clone()));
+                .insert(*receipt.receipt_id(), Arc::new(receipt.clone()));
         }
         self.chain_store_cache_update.chunks.insert(chunk.chunk_hash(), Arc::new(chunk));
     }

chain/chain/src/test_utils.rs

@@ -276,7 +276,7 @@ mod test {
     use rand::Rng;
 
     use near_primitives::hash::CryptoHash;
-    use near_primitives::receipt::Receipt;
+    use near_primitives::receipt::{Receipt, ReceiptPriority};
     use near_primitives::sharding::ReceiptList;
     use near_primitives::types::{AccountId, NumShards};
 
@@ -293,7 +293,7 @@ mod test {
             let shard_receipts: Vec<Receipt> = receipts
                 .iter()
                 .filter(|&receipt| {
-                    account_id_to_shard_id(&receipt.receiver_id, shard_layout) == shard_id
+                    account_id_to_shard_id(receipt.receiver_id(), shard_layout) == shard_id
                 })
                 .cloned()
                 .collect();
@@ -305,7 +305,7 @@ mod test {
     fn test_build_receipt_hashes_with_num_shard(num_shards: NumShards) {
         let shard_layout = ShardLayout::v0(num_shards, 0);
         let create_receipt_from_receiver_id =
-            |receiver_id| Receipt::new_balance_refund(&receiver_id, 0);
+            |receiver_id| Receipt::new_balance_refund(&receiver_id, 0, ReceiptPriority::NoPriority);
         let mut rng = rand::thread_rng();
         let receipts = (0..3000)
             .map(|_| {

chain/chain/src/test_utils/kv_runtime.rs

@@ -25,7 +25,7 @@ use near_primitives::epoch_manager::ShardConfig;
 use near_primitives::epoch_manager::ValidatorSelectionConfig;
 use near_primitives::errors::{EpochError, InvalidTxError};
 use near_primitives::hash::{hash, CryptoHash};
-use near_primitives::receipt::{ActionReceipt, Receipt, ReceiptEnum};
+use near_primitives::receipt::{ActionReceipt, Receipt, ReceiptEnum, ReceiptV0};
 use near_primitives::shard_layout::{ShardLayout, ShardUId};
 use near_primitives::sharding::{ChunkHash, ShardChunkHeader};
 use near_primitives::state_part::PartId;
@@ -1145,16 +1145,19 @@ impl RuntimeAdapter for KeyValueRuntime {
 
         for receipt in receipts.iter() {
             if let ReceiptEnum::Action(action) | ReceiptEnum::PromiseYield(action) =
-                &receipt.receipt
+                receipt.receipt()
             {
-                assert_eq!(account_id_to_shard_id(&receipt.receiver_id, self.num_shards), shard_id);
-                if !state.receipt_nonces.contains(&receipt.receipt_id) {
-                    state.receipt_nonces.insert(receipt.receipt_id);
+                assert_eq!(
+                    account_id_to_shard_id(receipt.receiver_id(), self.num_shards),
+                    shard_id
+                );
+                if !state.receipt_nonces.contains(receipt.receipt_id()) {
+                    state.receipt_nonces.insert(*receipt.receipt_id());
                     if let Action::Transfer(TransferAction { deposit }) = action.actions[0] {
                         balance_transfers.push((
                             receipt.get_hash(),
-                            receipt.predecessor_id.clone(),
-                            receipt.receiver_id.clone(),
+                            receipt.predecessor_id().clone(),
+                            receipt.receiver_id().clone(),
                             deposit,
                             0,
                         ));
@@ -1169,36 +1172,37 @@ impl RuntimeAdapter for KeyValueRuntime {
 
         for transaction in transactions {
             assert_eq!(
-                account_id_to_shard_id(&transaction.transaction.signer_id, self.num_shards),
+                account_id_to_shard_id(transaction.transaction.signer_id(), self.num_shards),
                 shard_id
             );
-            if transaction.transaction.actions.is_empty() {
+            if transaction.transaction.actions().is_empty() {
                 continue;
             }
-            if let Action::Transfer(TransferAction { deposit }) = transaction.transaction.actions[0]
+            if let Action::Transfer(TransferAction { deposit }) =
+                transaction.transaction.actions()[0]
             {
                 if !state.tx_nonces.contains(&AccountNonce(
-                    transaction.transaction.receiver_id.clone(),
-                    transaction.transaction.nonce,
+                    transaction.transaction.receiver_id().clone(),
+                    transaction.transaction.nonce(),
                 )) {
                     state.tx_nonces.insert(AccountNonce(
-                        transaction.transaction.receiver_id.clone(),
-                        transaction.transaction.nonce,
+                        transaction.transaction.receiver_id().clone(),
+                        transaction.transaction.nonce(),
                     ));
                     balance_transfers.push((
                         transaction.get_hash(),
-                        transaction.transaction.signer_id.clone(),
-                        transaction.transaction.receiver_id.clone(),
+                        transaction.transaction.signer_id().clone(),
+                        transaction.transaction.receiver_id().clone(),
                         deposit,
-                        transaction.transaction.nonce,
+                        transaction.transaction.nonce(),
                     ));
                 } else {
                     balance_transfers.push((
                         transaction.get_hash(),
-                        transaction.transaction.signer_id.clone(),
-                        transaction.transaction.receiver_id.clone(),
+                        transaction.transaction.signer_id().clone(),
+                        transaction.transaction.receiver_id().clone(),
                         0,
-                        transaction.transaction.nonce,
+                        transaction.transaction.nonce(),
                     ));
                 }
             } else {
@@ -1229,7 +1233,7 @@ impl RuntimeAdapter for KeyValueRuntime {
                     vec![]
                 } else {
                     assert_ne!(nonce, 0);
-                    let receipt = Receipt {
+                    let receipt = Receipt::V0(ReceiptV0 {
                         predecessor_id: from.clone(),
                         receiver_id: to.clone(),
                         receipt_id: create_receipt_nonce(from.clone(), to.clone(), amount, nonce),
@@ -1241,7 +1245,7 @@ impl RuntimeAdapter for KeyValueRuntime {
                             input_data_ids: vec![],
                             actions: vec![Action::Transfer(TransferAction { deposit: amount })],
                         }),
-                    };
+                    });
                     let receipt_hash = receipt.get_hash();
                     outgoing_receipts.push(receipt);
                     vec![receipt_hash]

chain/chain/src/validate.rs

@@ -78,10 +78,10 @@ pub fn validate_transactions_order(transactions: &[SignedTransaction]) -> bool {
     let mut current_batch = 1;
 
     for tx in transactions {
-        let key = (&tx.transaction.signer_id, &tx.transaction.public_key);
+        let key = (tx.transaction.signer_id(), tx.transaction.public_key());
 
         // Verifying nonce
-        let nonce = tx.transaction.nonce;
+        let nonce = tx.transaction.nonce();
         if let Some(last_nonce) = nonces.get(&key) {
             if nonce <= *last_nonce {
                 // Nonces should increase.

chain/chunks/src/client.rs

@@ -143,7 +143,7 @@ impl ShardedTransactionPool {
         }
 
         for tx in transactions {
-            let signer_id = &tx.transaction.signer_id;
+            let signer_id = tx.transaction.signer_id();
             let new_shard_uid = account_id_to_shard_uid(&signer_id, new_shard_layout);
             self.insert_transaction(new_shard_uid, tx);
         }
@@ -266,8 +266,8 @@ mod tests {
                 while let Some(group) = pool_iter.next() {
                     while let Some(tx) = group.next() {
                         total += 1;
-                        let account_id = tx.transaction.signer_id;
-                        let tx_shard_uid = account_id_to_shard_uid(&account_id, &new_shard_layout);
+                        let account_id = tx.transaction.signer_id();
+                        let tx_shard_uid = account_id_to_shard_uid(account_id, &new_shard_layout);
                         tracing::debug!("checking {account_id:?}:{tx_shard_uid} in {shard_uid}");
                         assert_eq!(shard_uid, tx_shard_uid);
                     }

chain/client/src/client.rs

@@ -1013,6 +1013,7 @@ impl Client {
                     "other".parse().unwrap(),
                     3,
                     prev_block_hash,
+                    0,
                 ),
             ));
             if txs.storage_proof.is_none() {
@@ -2112,7 +2113,7 @@ impl Client {
     /// Forwards given transaction to upcoming validators.
     fn forward_tx(&self, epoch_id: &EpochId, tx: &SignedTransaction) -> Result<(), Error> {
         let shard_id =
-            self.epoch_manager.account_id_to_shard_id(&tx.transaction.signer_id, epoch_id)?;
+            self.epoch_manager.account_id_to_shard_id(tx.transaction.signer_id(), epoch_id)?;
         // Use the header head to make sure the list of validators is as
         // up-to-date as possible.
         let head = self.chain.header_head()?;
@@ -2129,7 +2130,7 @@ impl Client {
             if let Some(next_epoch_id) = &maybe_next_epoch_id {
                 let next_shard_id = self
                     .epoch_manager
-                    .account_id_to_shard_id(&tx.transaction.signer_id, next_epoch_id)?;
+                    .account_id_to_shard_id(tx.transaction.signer_id(), next_epoch_id)?;
                 let validator = self.epoch_manager.get_chunk_producer(
                     next_epoch_id,
                     target_height,
@@ -2220,7 +2221,7 @@ impl Client {
         // `cur_block_header`.
         if let Err(e) = self.chain.chain_store().check_transaction_validity_period(
             &cur_block_header,
-            &tx.transaction.block_hash,
+            tx.transaction.block_hash(),
             transaction_validity_period,
         ) {
             debug!(target: "client", ?tx, "Invalid tx: expired or from a different fork");
@@ -2241,7 +2242,7 @@ impl Client {
         }
 
         let shard_id =
-            self.epoch_manager.account_id_to_shard_id(&tx.transaction.signer_id, &epoch_id)?;
+            self.epoch_manager.account_id_to_shard_id(tx.transaction.signer_id(), &epoch_id)?;
         let care_about_shard =
             self.shard_tracker.care_about_shard(me, &head.last_block_hash, shard_id, true);
         let will_care_about_shard =

chain/client/src/test_utils/test_env.rs

@@ -697,6 +697,7 @@ impl TestEnv {
             signer,
             actions,
             tip.last_block_hash,
+            0,
         )
     }
 
@@ -735,6 +736,7 @@ impl TestEnv {
             &relayer_signer,
             vec![Action::Delegate(Box::new(signed_delegate_action))],
             tip.last_block_hash,
+            0,
         )
     }