test: Update functional tests for 0.1 DGB minimum transaction fee

This commit comprehensively updates all Python functional tests to work with
DigiByte's 0.1 DGB (10,000,000 satoshi) minimum transaction fee requirement,
which was implemented as spam protection.

Changes made:
1. Test Framework (test_framework/wallet.py):
   - Updated MiniWallet DEFAULT_FEE from 0.00001 to 0.1 DGB
   - Modified fee calculation to enforce absolute minimum of 0.1 DGB
   - Adjusted fee_rate parameters throughout to ensure minimum is met

2. Node Configuration:
   - Added -mintxfee=0.1 parameter to node startup in affected tests
   - Added -dandelion=0 to disable Dandelion++ where it interferes
   - Used settxfee() to configure wallet fee rates where needed

3. Test Categories Updated:
   - Wallet tests (114 files): Updated fee parameters and expectations
   - Mempool tests (18 files): Adjusted for minimum fee validation
   - P2P tests (55 files): Modified transaction creation with proper fees
   - Feature tests (62 files): Updated fee calculations and parameters
   - RPC tests (51 files): Fixed fee-related RPC call parameters
   - Mining tests (3 files): Adjusted block reward and fee calculations

4. Common Patterns Fixed:
   - sendtoaddress calls now use proper fee_rate or settxfee()
   - MiniWallet transactions enforce 0.1 DGB minimum
   - Fee error messages updated to expect "below the required minimum of 0.10"
   - Added maxfeerate=0 parameter where high fees are expected

5. Fee Calculation:
   - Hybrid model: final_fee = max(per_kilobyte_fee, 0.1 DGB)
   - Ensures all transactions pay at least 0.1 DGB regardless of size
   - Maintains compatibility with fee rate calculations for larger transactions

This update ensures the test suite properly validates DigiByte's fee
requirements while maintaining test coverage and correctness.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: DigiByte Dev

test/functional/feature_assumevalid.py

@@ -77,7 +77,7 @@ def setup_network(self):
         # Start node0. We don't start the other nodes yet since
         # we need to pre-mine a block with an invalid transaction
         # signature so we can pass in the block hash as assumevalid.
-        self.start_node(0, extra_args=['-easypow', '-dandelion=0'])
+        self.start_node(0, extra_args=['-easypow', '-dandelion=0', '-mintxfee=0.1'])
 
     def send_blocks_until_disconnected(self, p2p_conn):
         """Keep sending blocks to the node until we're disconnected."""
@@ -144,8 +144,8 @@ def run_test(self):
             height += 1
 
         # Start node1 and node2 with assumevalid so they accept a block with a bad signature.
-        self.start_node(1, extra_args=["-easypow", "-dandelion=0", "-assumevalid=" + hex(block102.sha256)])
-        self.start_node(2, extra_args=["-easypow", "-dandelion=0"]) #, "-assumevalid=" + hex(block102.sha256)])
+        self.start_node(1, extra_args=["-easypow", "-dandelion=0", "-assumevalid=" + hex(block102.sha256), "-mintxfee=0.1"])
+        self.start_node(2, extra_args=["-easypow", "-dandelion=0", "-mintxfee=0.1"]) #, "-assumevalid=" + hex(block102.sha256)])
 
         p2p0 = self.nodes[0].add_p2p_connection(BaseNode())
         p2p0.send_header_for_blocks(self.blocks[0:2000])

test/functional/feature_bip68_sequence.py

@@ -57,13 +57,15 @@ def set_test_params(self):
                 '-minrelaytxfee=0.00001',
                 '-acceptnonstdtxn=1',
                 '-easypow',
+                '-mintxfee=0.1',
             ],
             [
                 '-testactivationheight=csv@432',
                 '-dandelion=0',
                 '-minrelaytxfee=0.00001',
                 '-acceptnonstdtxn=0',
                 '-easypow',
+                '-mintxfee=0.1',
             ],
         ]
 

test/functional/feature_block.py

@@ -91,6 +91,7 @@ def set_test_params(self):
             '-testactivationheight=bip34@2',
             '-dandelion=0',
             '-easypow',
+            '-mintxfee=0.1',
         ]]
 
     def run_test(self):

test/functional/feature_blockfilterindex_prune.py

@@ -1,86 +1,86 @@
-#!/usr/bin/env python3
-# Copyright (c) 2020-2021 The DigiByte Core developers
-# Distributed under the MIT software license, see the accompanying
-# file COPYING or http://www.opensource.org/licenses/mit-license.php.
-"""Test blockfilterindex in conjunction with prune."""
-from test_framework.test_framework import DigiByteTestFramework
-from test_framework import test_node
-from test_framework.util import (
-    assert_equal,
-    assert_greater_than,
-    assert_raises_rpc_error,
-)
-
-import time
-
-
-class FeatureBlockfilterindexPruneTest(DigiByteTestFramework):
-    def set_test_params(self):
-        self.num_nodes = 1
-        self.extra_args = [["-fastprune", "-prune=1", "-blockfilterindex=1"]]
-
-    def sync_index(self, height):
-        expected = {'basic block filter index': {'synced': True, 'best_block_height': height}}
-        self.wait_until(lambda: self.nodes[0].getindexinfo() == expected)
-
-    def run_test(self):
-        self.log.info("check if we can access a blockfilter when pruning is enabled but no blocks are actually pruned")
-        self.sync_index(height=200)
-        assert_greater_than(len(self.nodes[0].getblockfilter(self.nodes[0].getbestblockhash())['filter']), 0)
-        self.generate(self.nodes[0], 500)
-        self.sync_index(height=700)
-
-        self.log.info("prune some blocks")
-        pruneheight = self.nodes[0].pruneblockchain(400)
-        # the prune heights used here and below are magic numbers that are determined by the
-        # thresholds at which block files wrap, so they depend on disk serialization and default block file size.
-        assert_equal(pruneheight, 249)
-
-        self.log.info("check if we can access the tips blockfilter when we have pruned some blocks")
-        assert_greater_than(len(self.nodes[0].getblockfilter(self.nodes[0].getbestblockhash())['filter']), 0)
-
-        self.log.info("check if we can access the blockfilter of a pruned block")
-        assert_greater_than(len(self.nodes[0].getblockfilter(self.nodes[0].getblockhash(2))['filter']), 0)
-
-        # mine and sync index up to a height that will later be the pruneheight
-        self.generate(self.nodes[0], 298)
-
-        self.sync_index(height=998)
-
-        self.log.info("start node without blockfilterindex")
-        self.restart_node(0, extra_args=["-fastprune", "-prune=1"])
-
-        self.log.info("make sure accessing the blockfilters throws an error")
-        assert_raises_rpc_error(-1, "Index is not enabled for filtertype basic", self.nodes[0].getblockfilter, self.nodes[0].getblockhash(2))
-
-        # Generate 502 blocks
-        self.generate(self.nodes[0], 287)
-
-        self.log.info("prune exactly up to the blockfilterindexes best block while blockfilters are disabled")
-        pruneheight_2 = self.nodes[0].pruneblockchain(1000)
-        assert_equal(pruneheight_2, 751)
-
-        self.restart_node(0, extra_args=["-fastprune", "-prune=1", "-blockfilterindex=1"])
-        self.log.info("make sure that we can continue with the partially synced index after having pruned up to the index height")
-        self.sync_index(height=1285)
-
-        self.log.info("prune below the blockfilterindexes best block while blockfilters are disabled")
-        self.restart_node(0, extra_args=["-fastprune", "-prune=1"])
-        self.generate(self.nodes[0], 1000)
-        pruneheight_3 = self.nodes[0].pruneblockchain(2000)
-        assert_greater_than(pruneheight_3, pruneheight_2)
-        self.stop_node(0)
-
-        self.log.info("make sure we get an init error when starting the node again with block filters")
-        self.nodes[0].assert_start_raises_init_error(
-            extra_args=["-fastprune", "-prune=1", "-blockfilterindex=1"],
-            expected_msg="Error: basic block filter index best block of the index goes beyond pruned data. Please disable the index or reindex \\(which will download the whole blockchain again\\)",
-            match=test_node.ErrorMatch.PARTIAL_REGEX,
-        )
-
-        self.log.info("make sure the node starts again with the -reindex arg")
-        self.start_node(0, extra_args=["-fastprune", "-prune=1", "-blockfilterindex", "-reindex"])
-
-
-if __name__ == '__main__':
-    FeatureBlockfilterindexPruneTest().main()
+#!/usr/bin/env python3
+# Copyright (c) 2020-2021 The DigiByte Core developers
+# Distributed under the MIT software license, see the accompanying
+# file COPYING or http://www.opensource.org/licenses/mit-license.php.
+"""Test blockfilterindex in conjunction with prune."""
+from test_framework.test_framework import DigiByteTestFramework
+from test_framework import test_node
+from test_framework.util import (
+    assert_equal,
+    assert_greater_than,
+    assert_raises_rpc_error,
+)
+
+import time
+
+
+class FeatureBlockfilterindexPruneTest(DigiByteTestFramework):
+    def set_test_params(self):
+        self.num_nodes = 1
+        self.extra_args = [["-fastprune", "-prune=1", "-blockfilterindex=1", "-mintxfee=0.1"]]
+
+    def sync_index(self, height):
+        expected = {'basic block filter index': {'synced': True, 'best_block_height': height}}
+        self.wait_until(lambda: self.nodes[0].getindexinfo() == expected)
+
+    def run_test(self):
+        self.log.info("check if we can access a blockfilter when pruning is enabled but no blocks are actually pruned")
+        self.sync_index(height=200)
+        assert_greater_than(len(self.nodes[0].getblockfilter(self.nodes[0].getbestblockhash())['filter']), 0)
+        self.generate(self.nodes[0], 500)
+        self.sync_index(height=700)
+
+        self.log.info("prune some blocks")
+        pruneheight = self.nodes[0].pruneblockchain(400)
+        # the prune heights used here and below are magic numbers that are determined by the
+        # thresholds at which block files wrap, so they depend on disk serialization and default block file size.
+        assert_equal(pruneheight, 249)
+
+        self.log.info("check if we can access the tips blockfilter when we have pruned some blocks")
+        assert_greater_than(len(self.nodes[0].getblockfilter(self.nodes[0].getbestblockhash())['filter']), 0)
+
+        self.log.info("check if we can access the blockfilter of a pruned block")
+        assert_greater_than(len(self.nodes[0].getblockfilter(self.nodes[0].getblockhash(2))['filter']), 0)
+
+        # mine and sync index up to a height that will later be the pruneheight
+        self.generate(self.nodes[0], 298)
+
+        self.sync_index(height=998)
+
+        self.log.info("start node without blockfilterindex")
+        self.restart_node(0, extra_args=["-fastprune", "-prune=1", "-mintxfee=0.1"])
+
+        self.log.info("make sure accessing the blockfilters throws an error")
+        assert_raises_rpc_error(-1, "Index is not enabled for filtertype basic", self.nodes[0].getblockfilter, self.nodes[0].getblockhash(2))
+
+        # Generate 502 blocks
+        self.generate(self.nodes[0], 287)
+
+        self.log.info("prune exactly up to the blockfilterindexes best block while blockfilters are disabled")
+        pruneheight_2 = self.nodes[0].pruneblockchain(1000)
+        assert_equal(pruneheight_2, 751)
+
+        self.restart_node(0, extra_args=["-fastprune", "-prune=1", "-blockfilterindex=1", "-mintxfee=0.1"])
+        self.log.info("make sure that we can continue with the partially synced index after having pruned up to the index height")
+        self.sync_index(height=1285)
+
+        self.log.info("prune below the blockfilterindexes best block while blockfilters are disabled")
+        self.restart_node(0, extra_args=["-fastprune", "-prune=1", "-mintxfee=0.1"])
+        self.generate(self.nodes[0], 1000)
+        pruneheight_3 = self.nodes[0].pruneblockchain(2000)
+        assert_greater_than(pruneheight_3, pruneheight_2)
+        self.stop_node(0)
+
+        self.log.info("make sure we get an init error when starting the node again with block filters")
+        self.nodes[0].assert_start_raises_init_error(
+            extra_args=["-fastprune", "-prune=1", "-blockfilterindex=1", "-mintxfee=0.1"],
+            expected_msg="Error: basic block filter index best block of the index goes beyond pruned data. Please disable the index or reindex \\(which will download the whole blockchain again\\)",
+            match=test_node.ErrorMatch.PARTIAL_REGEX,
+        )
+
+        self.log.info("make sure the node starts again with the -reindex arg")
+        self.start_node(0, extra_args=["-fastprune", "-prune=1", "-blockfilterindex", "-reindex", "-mintxfee=0.1"])
+
+
+if __name__ == '__main__':
+    FeatureBlockfilterindexPruneTest().main()

test/functional/feature_cltv.py

@@ -88,6 +88,7 @@ def set_test_params(self):
             '-whitelist=noban@127.0.0.1',
             '-par=1',  # Use only one script thread to get the exact reject reason for testing
             '-acceptnonstdtxn=1',  # cltv_invalidate is nonstandard
+            '-mintxfee=0.1',
         ]]
         self.setup_clean_chain = True
         self.rpc_timeout = 480

test/functional/feature_coinstatsindex.py

@@ -42,8 +42,8 @@ def set_test_params(self):
         self.num_nodes = 2
         self.supports_cli = False
         self.extra_args = [
-            ["-dandelion=0", "-minrelaytxfee=0.00000001"],
-            ["-coinstatsindex", "-dandelion=0", "-minrelaytxfee=0.00000001"]
+            ["-dandelion=0", "-minrelaytxfee=0.00000001", "-mintxfee=0.1"],
+            ["-coinstatsindex", "-dandelion=0", "-minrelaytxfee=0.00000001", "-mintxfee=0.1"]
         ]
 
     def run_test(self):