add test for no fee tx anchored directly and failure to submit it to mempool

Author: ASuciuX

stackslib/src/chainstate/stacks/tests/block_construction.rs

@@ -1536,6 +1536,225 @@ fn test_build_anchored_blocks_skip_too_expensive() {
     }
 }
 
+#[test]
+fn test_build_anchored_blocks_mempool_fee_transaction_too_low() {
+    let privk = StacksPrivateKey::from_hex(
+        "42faca653724860da7a41bfcef7e6ba78db55146f6900de8cb2a9f760ffac70c01",
+    )
+    .unwrap();
+    let addr = StacksAddress::from_public_keys(
+        C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+        &AddressHashMode::SerializeP2PKH,
+        1,
+        &vec![StacksPublicKey::from_private(&privk)],
+    )
+    .unwrap();
+
+    let mut peer_config = TestPeerConfig::new(function_name!(), 2032, 2033);
+    peer_config.initial_balances = vec![(addr.to_account_principal(), 1000000000)];
+    let burnchain = peer_config.burnchain.clone();
+
+    let mut peer = TestPeer::new(peer_config);
+
+    let chainstate_path = peer.chainstate_path.clone();
+
+    let recipient_addr_str = "ST1RFD5Q2QPK3E0F08HG9XDX7SSC7CNRS0QR0SGEV";
+    let recipient = StacksAddress::from_string(recipient_addr_str).unwrap();
+
+    let tip =
+        SortitionDB::get_canonical_burn_chain_tip(&peer.sortdb.as_ref().unwrap().conn()).unwrap();
+
+    let (burn_ops, stacks_block, microblocks) = peer.make_tenure(
+        |ref mut miner,
+         ref mut sortdb,
+         ref mut chainstate,
+         vrf_proof,
+         ref parent_opt,
+         ref parent_microblock_header_opt| {
+            let parent_tip = match parent_opt {
+                None => StacksChainState::get_genesis_header_info(chainstate.db()).unwrap(),
+                Some(block) => {
+                    let ic = sortdb.index_conn();
+                    let snapshot = SortitionDB::get_block_snapshot_for_winning_stacks_block(
+                        &ic,
+                        &tip.sortition_id,
+                        &block.block_hash(),
+                    )
+                    .unwrap()
+                    .unwrap();
+                    StacksChainState::get_anchored_block_header_info(
+                        chainstate.db(),
+                        &snapshot.consensus_hash,
+                        &snapshot.winning_stacks_block_hash,
+                    )
+                    .unwrap()
+                    .unwrap()
+                }
+            };
+
+            let parent_header_hash = parent_tip.anchored_header.block_hash();
+            let parent_consensus_hash = parent_tip.consensus_hash.clone();
+
+            let mut mempool = MemPoolDB::open_test(false, 0x80000000, &chainstate_path).unwrap();
+
+            let coinbase_tx = make_coinbase(miner, 0);
+
+            // Create a zero-fee transaction
+            let zero_fee_tx = make_user_stacks_transfer(
+                &privk,
+                0,
+                0, // Set fee to 0
+                &recipient.to_account_principal(),
+                1000,
+            );
+
+            let result = mempool.submit(
+                chainstate,
+                sortdb,
+                &parent_consensus_hash,
+                &parent_header_hash,
+                &zero_fee_tx,
+                None,
+                &ExecutionCost::max_value(),
+                &StacksEpochId::Epoch20,
+            );
+
+            match result {
+                Ok(_) => panic!("Expected FeeTooLow error but transaction was accepted"),
+                Err(e) => match e {
+                    MemPoolRejection::FeeTooLow(actual, required) => {
+                        assert_eq!(actual, 0);
+                        assert_eq!(required, 180);
+                    }
+                    _ => panic!("Unexpected error: {:?}", e),
+                },
+            };
+
+            let anchored_block = StacksBlockBuilder::build_anchored_block(
+                chainstate,
+                &sortdb.index_handle_at_tip(),
+                &mut mempool,
+                &parent_tip,
+                tip.total_burn,
+                vrf_proof,
+                Hash160([0 as u8; 20]),
+                &coinbase_tx,
+                BlockBuilderSettings::max_value(),
+                None,
+                &burnchain,
+            )
+            .unwrap();
+
+            (anchored_block.0, vec![])
+        },
+    );
+
+    peer.next_burnchain_block(burn_ops.clone());
+    peer.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
+
+    // Check that the block contains only coinbase transactions (coinbase)
+    assert_eq!(stacks_block.txs.len(), 1);
+}
+
+#[test]
+fn test_build_anchored_blocks_zero_fee_transaction() {
+    let privk = StacksPrivateKey::from_hex(
+        "42faca653724860da7a41bfcef7e6ba78db55146f6900de8cb2a9f760ffac70c01",
+    )
+    .unwrap();
+    let addr = StacksAddress::from_public_keys(
+        C32_ADDRESS_VERSION_TESTNET_SINGLESIG,
+        &AddressHashMode::SerializeP2PKH,
+        1,
+        &vec![StacksPublicKey::from_private(&privk)],
+    )
+    .unwrap();
+
+    let mut peer_config = TestPeerConfig::new(function_name!(), 2032, 2033);
+    peer_config.initial_balances = vec![(addr.to_account_principal(), 1000000000)];
+    let burnchain = peer_config.burnchain.clone();
+
+    let mut peer = TestPeer::new(peer_config);
+
+    let chainstate_path = peer.chainstate_path.clone();
+
+    let recipient_addr_str = "ST1RFD5Q2QPK3E0F08HG9XDX7SSC7CNRS0QR0SGEV";
+    let recipient = StacksAddress::from_string(recipient_addr_str).unwrap();
+
+    let tip =
+        SortitionDB::get_canonical_burn_chain_tip(&peer.sortdb.as_ref().unwrap().conn()).unwrap();
+
+    let (burn_ops, stacks_block, microblocks) = peer.make_tenure(
+        |ref mut miner,
+         ref mut sortdb,
+         ref mut chainstate,
+         vrf_proof,
+         ref parent_opt,
+         ref parent_microblock_header_opt| {
+            let parent_tip = match parent_opt {
+                None => StacksChainState::get_genesis_header_info(chainstate.db()).unwrap(),
+                Some(block) => {
+                    let ic = sortdb.index_conn();
+                    let snapshot = SortitionDB::get_block_snapshot_for_winning_stacks_block(
+                        &ic,
+                        &tip.sortition_id,
+                        &block.block_hash(),
+                    )
+                    .unwrap()
+                    .unwrap();
+                    StacksChainState::get_anchored_block_header_info(
+                        chainstate.db(),
+                        &snapshot.consensus_hash,
+                        &snapshot.winning_stacks_block_hash,
+                    )
+                    .unwrap()
+                    .unwrap()
+                }
+            };
+
+            let coinbase_tx = make_coinbase(miner, 0);
+
+            // Create a zero-fee transaction
+            let zero_fee_tx = make_user_stacks_transfer(
+                &privk,
+                0,
+                0, // Set fee to 0
+                &recipient.to_account_principal(),
+                1000,
+            );
+
+            let block_builder = StacksBlockBuilder::make_regtest_block_builder(
+                &burnchain,
+                &parent_tip,
+                vrf_proof,
+                tip.total_burn,
+                Hash160([0 as u8; 20]),
+            )
+            .unwrap();
+
+            let anchored_block = StacksBlockBuilder::make_anchored_block_from_txs(
+                block_builder,
+                chainstate,
+                &sortdb.index_handle_at_tip(),
+                vec![coinbase_tx, zero_fee_tx],
+            )
+            .unwrap();
+
+            (anchored_block.0, vec![])
+        },
+    );
+
+    peer.next_burnchain_block(burn_ops.clone());
+    peer.process_stacks_epoch_at_tip(&stacks_block, &microblocks);
+
+    // Check that the block contains 2 transactions (coinbase + zero-fee transaction)
+    assert_eq!(stacks_block.txs.len(), 2);
+
+    // Verify that the zero-fee transaction is in the block
+    let zero_fee_tx = &stacks_block.txs[1];
+    assert_eq!(zero_fee_tx.get_tx_fee(), 0);
+}
+
 #[test]
 fn test_build_anchored_blocks_multiple_chaintips() {
     let mut privks = vec![];