chia-blockchain 2.5.1rc1__py3-none-any.whl

chia/_tests/fee_estimation/test_fee_estimation_integration.py

@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+import types
+
+import pytest
+from chia_rs import Coin
+
+from chia._tests.core.mempool.test_mempool_manager import (
+    create_test_block_record,
+    instantiate_mempool_manager,
+    zero_calls_get_coin_records,
+)
+from chia.full_node.bitcoin_fee_estimator import create_bitcoin_fee_estimator
+from chia.full_node.fee_estimation import (
+    EmptyFeeMempoolInfo,
+    EmptyMempoolInfo,
+    FeeBlockInfo,
+    FeeMempoolInfo,
+    MempoolInfo,
+    MempoolItemInfo,
+)
+from chia.full_node.fee_estimator_interface import FeeEstimatorInterface
+from chia.full_node.fee_tracker import FeeTracker
+from chia.full_node.mempool import Mempool, MempoolRemoveReason
+from chia.simulator.block_tools import test_constants
+from chia.simulator.wallet_tools import WalletTool
+from chia.types.clvm_cost import CLVMCost
+from chia.types.fee_rate import FeeRate, FeeRateV2
+from chia.types.mempool_item import MempoolItem
+from chia.types.spend_bundle_conditions import SpendBundleConditions, SpendConditions
+from chia.util.ints import uint32, uint64
+
+
+def make_mempoolitem() -> MempoolItem:
+    wallet_tool = WalletTool(test_constants)
+    ph = wallet_tool.get_new_puzzlehash()
+    coin = Coin(ph, ph, uint64(10000))
+    spend_bundle = wallet_tool.generate_signed_transaction(uint64(10000), ph, coin)
+    cost = uint64(1000000)
+    block_height = 1
+
+    fee = uint64(10000000)
+    spends: list[SpendConditions] = []
+    conds = SpendBundleConditions(spends, 0, 0, 0, None, None, [], cost, 0, 0, False, 0, 0)
+    mempool_item = MempoolItem(
+        spend_bundle,
+        fee,
+        conds,
+        spend_bundle.name(),
+        uint32(block_height),
+    )
+    return mempool_item
+
+
+class FeeEstimatorInterfaceIntegrationVerificationObject(FeeEstimatorInterface):
+    add_mempool_item_called_count: int = 0
+    remove_mempool_item_called_count: int = 0
+    new_block_called_count: int = 0
+    current_block_height: int = 0
+
+    def new_block_height(self, block_height: uint32) -> None:
+        self.current_block_height: int = block_height
+
+    def new_block(self, block_info: FeeBlockInfo) -> None:
+        """A new block has been added to the blockchain"""
+        self.current_block_height = block_info.block_height
+        self.new_block_called_count += 1
+
+    def add_mempool_item(self, mempool_info: FeeMempoolInfo, mempool_item: MempoolItemInfo) -> None:
+        """A MempoolItem (transaction and associated info) has been added to the mempool"""
+        self.add_mempool_item_called_count += 1
+
+    def remove_mempool_item(self, mempool_info: FeeMempoolInfo, mempool_item: MempoolItemInfo) -> None:
+        """A MempoolItem (transaction and associated info) has been removed from the mempool"""
+        self.remove_mempool_item_called_count += 1
+
+    def estimate_fee_rate(self, *, time_offset_seconds: int) -> FeeRateV2:
+        """time_offset_seconds: number of seconds into the future for which to estimate fee"""
+        return FeeRateV2(0)
+
+    def mempool_size(self) -> CLVMCost:
+        """Report last seen mempool size"""
+        return CLVMCost(uint64(0))
+
+    def mempool_max_size(self) -> CLVMCost:
+        """Report current mempool max "size" (i.e. CLVM cost)"""
+        return CLVMCost(uint64(0))
+
+    def get_mempool_info(self) -> FeeMempoolInfo:
+        """Report Mempool current configuration and state"""
+        return EmptyFeeMempoolInfo
+
+
+def test_mempool_fee_estimator_init() -> None:
+    max_block_cost = uint64(1000 * 1000)
+    fee_estimator = create_bitcoin_fee_estimator(max_block_cost)
+    mempool = Mempool(EmptyMempoolInfo, fee_estimator)
+    assert mempool.fee_estimator
+
+
+test_mempool_info = MempoolInfo(
+    max_size_in_cost=CLVMCost(uint64(5000000)),
+    minimum_fee_per_cost_to_replace=FeeRate(uint64(5)),
+    max_block_clvm_cost=CLVMCost(uint64(1000000)),
+)
+
+
+def test_mempool_fee_estimator_add_item() -> None:
+    fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
+    mempool = Mempool(test_mempool_info, fee_estimator)
+    item = make_mempoolitem()
+    mempool.add_to_pool(item)
+    assert mempool.fee_estimator.add_mempool_item_called_count == 1  # type: ignore[attr-defined]
+
+
+def test_item_not_removed_if_not_added() -> None:
+    for reason in MempoolRemoveReason:
+        fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
+        mempool = Mempool(test_mempool_info, fee_estimator)
+        item = make_mempoolitem()
+        with pytest.raises(KeyError):
+            mempool.remove_from_pool([item.name], reason)
+        assert mempool.fee_estimator.remove_mempool_item_called_count == 0  # type: ignore[attr-defined]
+
+
+def test_mempool_fee_estimator_remove_item() -> None:
+    should_call_fee_estimator_remove: dict[MempoolRemoveReason, int] = {
+        MempoolRemoveReason.BLOCK_INCLUSION: 0,
+        MempoolRemoveReason.CONFLICT: 1,
+        MempoolRemoveReason.POOL_FULL: 1,
+    }
+    for reason, call_count in should_call_fee_estimator_remove.items():
+        fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
+        mempool = Mempool(test_mempool_info, fee_estimator)
+        item = make_mempoolitem()
+        mempool.add_to_pool(item)
+        mempool.remove_from_pool([item.name], reason)
+        assert mempool.fee_estimator.remove_mempool_item_called_count == call_count  # type: ignore[attr-defined]
+
+
+def test_mempool_manager_fee_estimator_new_block() -> None:
+    fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
+    mempool = Mempool(test_mempool_info, fee_estimator)
+    item = make_mempoolitem()
+    height = uint32(4)
+    included_items = [MempoolItemInfo(item.cost, item.fee, item.height_added_to_mempool)]
+    mempool.fee_estimator.new_block(FeeBlockInfo(height, included_items))
+    assert mempool.fee_estimator.new_block_called_count == 1  # type: ignore[attr-defined]
+
+
+def test_current_block_height_init() -> None:
+    fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
+    mempool = Mempool(test_mempool_info, fee_estimator)
+    assert mempool.fee_estimator.current_block_height == uint32(0)  # type: ignore[attr-defined]
+
+
+def test_current_block_height_add() -> None:
+    fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
+    mempool = Mempool(test_mempool_info, fee_estimator)
+    item = make_mempoolitem()
+    height = uint32(7)
+    fee_estimator.new_block_height(height)
+    mempool.add_to_pool(item)
+    assert mempool.fee_estimator.current_block_height == height  # type: ignore[attr-defined]
+
+
+def test_current_block_height_remove() -> None:
+    fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
+    mempool = Mempool(test_mempool_info, fee_estimator)
+    item = make_mempoolitem()
+    height = uint32(8)
+    fee_estimator.new_block_height(height)
+    mempool.add_to_pool(item)
+    mempool.remove_from_pool([item.name], MempoolRemoveReason.CONFLICT)
+    assert mempool.fee_estimator.current_block_height == height  # type: ignore[attr-defined]
+
+
+def test_current_block_height_new_block_height() -> None:
+    fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
+    mempool = Mempool(test_mempool_info, fee_estimator)
+    height = uint32(9)
+    mempool.fee_estimator.new_block_height(height)
+    assert mempool.fee_estimator.current_block_height == height  # type: ignore[attr-defined]
+
+
+def test_current_block_height_new_block() -> None:
+    fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
+    mempool = Mempool(test_mempool_info, fee_estimator)
+    height = uint32(10)
+    included_items: list[MempoolItemInfo] = []
+    mempool.fee_estimator.new_block(FeeBlockInfo(height, included_items))
+    assert mempool.fee_estimator.current_block_height == height  # type: ignore[attr-defined]
+
+
+def test_current_block_height_new_height_then_new_block() -> None:
+    fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
+    mempool = Mempool(test_mempool_info, fee_estimator)
+    height = uint32(11)
+    included_items: list[MempoolItemInfo] = []
+    fee_estimator.new_block_height(uint32(height - 1))
+    mempool.fee_estimator.new_block(FeeBlockInfo(height, included_items))
+    assert mempool.fee_estimator.current_block_height == height  # type: ignore[attr-defined]
+
+
+def test_current_block_height_new_block_then_new_height() -> None:
+    fee_estimator = FeeEstimatorInterfaceIntegrationVerificationObject()
+    mempool = Mempool(test_mempool_info, fee_estimator)
+    height = uint32(12)
+    included_items: list[MempoolItemInfo] = []
+    fee_estimator.new_block_height(uint32(height - 1))
+    mempool.fee_estimator.new_block(FeeBlockInfo(height, included_items))
+    fee_estimator.new_block_height(uint32(height + 1))
+    assert mempool.fee_estimator.current_block_height == height + 1  # type: ignore[attr-defined]
+
+
+@pytest.mark.anyio
+async def test_mm_new_peak_changes_fee_estimator_block_height() -> None:
+    mempool_manager = await instantiate_mempool_manager(zero_calls_get_coin_records)
+    block2 = create_test_block_record(height=uint32(2))
+    await mempool_manager.new_peak(block2, None)
+    assert mempool_manager.mempool.fee_estimator.block_height == uint32(2)  # type: ignore[attr-defined]
+
+
+@pytest.mark.anyio
+async def test_mm_calls_new_block_height() -> None:
+    mempool_manager = await instantiate_mempool_manager(zero_calls_get_coin_records)
+    new_block_height_called = False
+
+    def test_new_block_height_called(self: FeeEstimatorInterface, height: uint32) -> None:
+        nonlocal new_block_height_called
+        new_block_height_called = True
+
+    # Replace new_block_height with test function
+    mempool_manager.fee_estimator.new_block_height = types.MethodType(  # type: ignore[method-assign]
+        test_new_block_height_called, mempool_manager.fee_estimator
+    )
+    block2 = create_test_block_record(height=uint32(2))
+    await mempool_manager.new_peak(block2, None)
+    assert new_block_height_called
+
+
+def test_add_tx_called() -> None:
+    max_block_cost = uint64(1000 * 1000)
+    fee_estimator = create_bitcoin_fee_estimator(max_block_cost)
+    mempool = Mempool(test_mempool_info, fee_estimator)
+    item = make_mempoolitem()
+
+    add_tx_called = False
+
+    def add_tx_called_fun(self: FeeTracker, mitem: MempoolItem) -> None:
+        nonlocal add_tx_called
+        add_tx_called = True
+
+    # Replace with test method
+    mempool.fee_estimator.tracker.add_tx = types.MethodType(  # type: ignore[attr-defined]
+        add_tx_called_fun,
+        mempool.fee_estimator.tracker,  # type: ignore[attr-defined]
+    )
+
+    mempool.add_to_pool(item)
+
+    assert add_tx_called

chia/_tests/fee_estimation/test_fee_estimation_rpc.py

@@ -0,0 +1,287 @@
+from __future__ import annotations
+
+import re
+from typing import Any
+
+import pytest
+
+from chia.rpc.full_node_rpc_api import FullNodeRpcApi
+from chia.rpc.full_node_rpc_client import FullNodeRpcClient
+from chia.simulator.block_tools import BlockTools
+from chia.simulator.full_node_simulator import FullNodeSimulator
+from chia.simulator.simulator_protocol import FarmNewBlockProtocol
+from chia.simulator.start_simulator import SimulatorFullNodeService
+from chia.simulator.wallet_tools import WalletTool
+from chia.types.aliases import WalletService
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.spend_bundle import SpendBundle
+from chia.util.ints import uint64
+
+
+@pytest.fixture(scope="function")
+async def setup_node_and_rpc(
+    two_wallet_nodes_services: tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools],
+) -> tuple[FullNodeRpcClient, FullNodeRpcApi]:
+    full_nodes, wallets, bt = two_wallet_nodes_services
+    wallet = wallets[0]._node.wallet_state_manager.main_wallet
+    full_node_apis = [full_node_service._api for full_node_service in full_nodes]
+    full_node_api: FullNodeSimulator = full_node_apis[0]
+    full_node_service_1 = full_nodes[0]
+    assert full_node_service_1.rpc_server is not None
+    client = await FullNodeRpcClient.create(
+        bt.config["self_hostname"],
+        full_node_service_1.rpc_server.listen_port,
+        full_node_service_1.root_path,
+        full_node_service_1.config,
+    )
+    full_node_rpc_api = FullNodeRpcApi(full_node_api.full_node)
+
+    ph = await wallet.get_new_puzzlehash()
+
+    for i in range(4):
+        await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
+
+    return client, full_node_rpc_api
+
+
+@pytest.fixture(scope="function")
+async def one_node_no_blocks(
+    one_node: tuple[list[SimulatorFullNodeService], list[WalletService], BlockTools],
+) -> tuple[FullNodeRpcClient, FullNodeRpcApi]:
+    full_nodes, _wallets, bt = one_node
+    full_node_apis = [full_node_service._api for full_node_service in full_nodes]
+    full_node_api: FullNodeSimulator = full_node_apis[0]
+    full_node_service_1 = full_nodes[0]
+    assert full_node_service_1.rpc_server is not None
+    client = await FullNodeRpcClient.create(
+        bt.config["self_hostname"],
+        full_node_service_1.rpc_server.listen_port,
+        full_node_service_1.root_path,
+        full_node_service_1.config,
+    )
+    full_node_rpc_api = FullNodeRpcApi(full_node_api.full_node)
+
+    return client, full_node_rpc_api
+
+
+@pytest.mark.anyio
+async def test_get_blockchain_state(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    # Confirm full node setup correctly
+    client, _ = setup_node_and_rpc
+    response = await client.get_blockchain_state()
+    assert response["genesis_challenge_initialized"] is True
+
+
+@pytest.mark.anyio
+async def test_empty_request(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+
+    with pytest.raises(ValueError):
+        await full_node_rpc_api.get_fee_estimate({})
+
+
+@pytest.mark.anyio
+async def test_empty_peak(one_node_no_blocks: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = one_node_no_blocks
+    response = await full_node_rpc_api.get_fee_estimate({"target_times": [], "cost": 1})
+    del response["node_time_utc"]
+    assert response == {
+        "estimates": [],
+        "target_times": [],
+        "current_fee_rate": 0,
+        "mempool_size": 0,
+        "mempool_max_size": 0,
+        "full_node_synced": False,
+        "peak_height": 0,
+        "last_peak_timestamp": 0,
+        "fee_rate_last_block": 0.0,
+        "fees_last_block": 0,
+        "last_block_cost": 0,
+        "last_tx_block_height": 0,
+        "mempool_fees": 0,
+        "num_spends": 0,
+    }
+
+
+@pytest.mark.anyio
+async def test_no_target_times(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    with pytest.raises(ValueError):
+        await full_node_rpc_api.get_fee_estimate({"cost": 1})
+
+
+@pytest.mark.anyio
+async def test_negative_time(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    with pytest.raises(ValueError):
+        await full_node_rpc_api.get_fee_estimate({"cost": 1, "target_times": [-1]})
+
+
+@pytest.mark.anyio
+async def test_negative_cost(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    with pytest.raises(ValueError):
+        await full_node_rpc_api.get_fee_estimate({"cost": -1, "target_times": [1]})
+
+
+@pytest.mark.anyio
+async def test_no_cost_or_tx(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    with pytest.raises(ValueError):
+        await full_node_rpc_api.get_fee_estimate({"target_times": []})
+
+
+@pytest.mark.anyio
+async def test_both_cost_and_tx(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    with pytest.raises(ValueError):
+        await full_node_rpc_api.get_fee_estimate({"target_times": [], "cost": 1, "spend_bundle": "80"})
+
+
+@pytest.mark.anyio
+async def test_target_times_invalid_type(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    with pytest.raises(TypeError):
+        await full_node_rpc_api.get_fee_estimate({"target_times": 1, "cost": 1})
+
+
+@pytest.mark.anyio
+async def test_cost_invalid_type(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    with pytest.raises(ValueError):
+        await full_node_rpc_api.get_fee_estimate({"target_times": [], "cost": "a lot"})
+
+
+@pytest.mark.anyio
+async def test_tx_invalid_type(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    with pytest.raises(TypeError):
+        await full_node_rpc_api.get_fee_estimate({"target_times": [], "spend_bundle": {"coin_spends": 1}})
+
+
+#####################
+
+
+@pytest.mark.anyio
+async def test_empty_target_times(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    response = await full_node_rpc_api.get_fee_estimate({"target_times": [], "cost": 1})
+    assert response["estimates"] == []
+    assert response["target_times"] == []
+
+
+@pytest.mark.anyio
+async def test_cost(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    response = await full_node_rpc_api.get_fee_estimate({"target_times": [1], "cost": 1})
+    assert response["estimates"] == [0]
+    assert response["target_times"] == [1]
+
+
+@pytest.mark.anyio
+async def test_tx(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    wallet_a: WalletTool = bt.get_pool_wallet_tool()
+    my_puzzle_hash = wallet_a.get_new_puzzlehash()
+    recevier_puzzle_hash = bytes32(b"0" * 32)
+    coin_to_spend = Coin(bytes32(b"0" * 32), my_puzzle_hash, uint64(1750000000000))
+    spend_bundle = wallet_a.generate_signed_transaction(
+        uint64(coin_to_spend.amount), recevier_puzzle_hash, coin_to_spend
+    )
+    response = await full_node_rpc_api.get_fee_estimate(
+        {"target_times": [1], "spend_bundle": spend_bundle.to_json_dict()}
+    )
+    assert response["estimates"] == [0]
+    assert response["target_times"] == [1]
+
+
+@pytest.mark.anyio
+async def test_multiple(setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi]) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    response = await full_node_rpc_api.get_fee_estimate({"target_times": [1, 5, 10, 15, 60, 120, 180, 240], "cost": 1})
+    assert response["estimates"] == [0, 0, 0, 0, 0, 0, 0, 0]
+    assert response["target_times"] == [1, 5, 10, 15, 60, 120, 180, 240]
+
+
+def get_test_spendbundle(bt: BlockTools) -> SpendBundle:
+    wallet_a: WalletTool = bt.get_pool_wallet_tool()
+    my_puzzle_hash = wallet_a.get_new_puzzlehash()
+    recevier_puzzle_hash = bytes32(b"0" * 32)
+    coin_to_spend = Coin(bytes32(b"0" * 32), my_puzzle_hash, uint64(1750000000000))
+    return wallet_a.generate_signed_transaction(uint64(coin_to_spend.amount), recevier_puzzle_hash, coin_to_spend)
+
+
+@pytest.mark.anyio
+async def test_validate_fee_estimate_cost_err(
+    setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
+) -> None:
+    spend_bundle = get_test_spendbundle(bt)
+    _client, full_node_rpc_api = setup_node_and_rpc
+    bad_arglist: list[list[Any]] = [
+        [["foo", "bar"]],
+        [["spend_bundle", spend_bundle.to_json_dict()], ["cost", 1]],
+        [["spend_bundle", spend_bundle.to_json_dict()], ["spend_type", "send_xch_transaction"]],
+        [["cost", 1], ["spend_type", "send_xch_transaction"]],
+        [["spend_bundle", spend_bundle.to_json_dict()], ["cost", 1], ["spend_type", "send_xch_transaction"]],
+    ]
+    for args in bad_arglist:
+        print(args)
+        request = {"target_times": [1]}
+        for var, val in args:
+            print(var)
+            request[var] = val
+        with pytest.raises(
+            ValueError, match=re.escape("Request must contain exactly one of ['spend_bundle', 'cost', 'spend_type']")
+        ):
+            _ = await full_node_rpc_api.get_fee_estimate(request)
+
+
+@pytest.mark.anyio
+async def test_validate_fee_estimate_cost_ok(
+    setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
+) -> None:
+    spend_bundle = get_test_spendbundle(bt)
+    _client, full_node_rpc_api = setup_node_and_rpc
+
+    good_arglist: list[list[Any]] = [
+        ["spend_bundle", spend_bundle.to_json_dict()],
+        ["cost", 1],
+        ["spend_type", "send_xch_transaction"],
+    ]
+    for var, val in good_arglist:
+        request = {"target_times": [1]}
+        request[var] = val
+        _ = await full_node_rpc_api.get_fee_estimate(request)
+
+
+@pytest.mark.anyio
+async def test_get_spendbundle_type_cost_missing(
+    setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
+) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    with pytest.raises(KeyError, match=re.escape("INVALID")):
+        request = {"target_times": [1], "spend_type": "INVALID"}
+        _ = await full_node_rpc_api.get_fee_estimate(request)
+
+
+@pytest.mark.anyio
+async def test_get_spendbundle_type_cost_spend_count_ok(
+    setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
+) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    spend_counts = [0, 1, 2]
+    for spend_count in spend_counts:
+        request = {"target_times": [1], "spend_type": "send_xch_transaction", "spend_count": spend_count}
+        ret = await full_node_rpc_api.get_fee_estimate(request)
+        print(spend_count, ret)
+
+
+@pytest.mark.anyio
+async def test_get_spendbundle_type_cost_spend_count_bad(
+    setup_node_and_rpc: tuple[FullNodeRpcClient, FullNodeRpcApi], bt: BlockTools
+) -> None:
+    _client, full_node_rpc_api = setup_node_and_rpc
+    with pytest.raises(ValueError):
+        request = {"target_times": [1], "spend_type": "send_xch_transaction", "spend_count": -1}
+        _ = await full_node_rpc_api.get_fee_estimate(request)

chia/_tests/fee_estimation/test_fee_estimation_unit_tests.py

@@ -0,0 +1,144 @@
+from __future__ import annotations
+
+import logging
+
+import pytest
+
+from chia.full_node.bitcoin_fee_estimator import create_bitcoin_fee_estimator
+from chia.full_node.fee_estimation import FeeBlockInfo, MempoolItemInfo
+from chia.full_node.fee_estimator_constants import INFINITE_FEE_RATE, INITIAL_STEP
+from chia.full_node.fee_estimator_interface import FeeEstimatorInterface
+from chia.full_node.fee_tracker import get_bucket_index, init_buckets
+from chia.types.fee_rate import FeeRateV2
+from chia.util.ints import uint32, uint64
+from chia.util.math import make_monotonically_decreasing
+
+log = logging.getLogger(__name__)
+
+
+def test_interface() -> None:
+    max_block_cost_clvm = uint64(1000 * 1000)
+    estimator: FeeEstimatorInterface = create_bitcoin_fee_estimator(max_block_cost_clvm)
+    target_times = [0, 120, 300]
+    estimates = [estimator.estimate_fee_rate(time_offset_seconds=time) for time in target_times]
+    current_fee_rate = estimator.estimate_fee_rate(
+        time_offset_seconds=1,
+    )
+    zero = FeeRateV2(0)
+    assert estimates == [zero, zero, zero]
+    assert current_fee_rate.mojos_per_clvm_cost == 0
+
+
+def test_estimator_create() -> None:
+    max_block_cost_clvm = uint64(1000 * 1000)
+    estimator = create_bitcoin_fee_estimator(max_block_cost_clvm)
+    assert estimator is not None
+
+
+def test_single_estimate() -> None:
+    max_block_cost_clvm = uint64(1000 * 1000)
+    estimator = create_bitcoin_fee_estimator(max_block_cost_clvm)
+    height = uint32(1)
+    estimator.new_block(FeeBlockInfo(height, []))
+    fee_rate = estimator.estimate_fee_rate(time_offset_seconds=40 * height)
+    assert fee_rate.mojos_per_clvm_cost == 0
+
+
+def make_block(
+    height: uint32, num_tx: int, cost: uint64, fee: uint64, num_blocks_wait_in_mempool: int
+) -> list[MempoolItemInfo]:
+    block_included = uint32(height - num_blocks_wait_in_mempool)
+    return [MempoolItemInfo(cost, fee, block_included)] * num_tx
+
+
+def test_steady_fee_pressure() -> None:
+    """
+    We submit successive blocks containing transactions with identical FeeRates.
+    We expect the estimator to converge on this FeeRate value.
+    """
+    max_block_cost_clvm = uint64(1000 * 1000)
+    estimator = create_bitcoin_fee_estimator(max_block_cost_clvm)
+    cost = uint64(5000000)
+    fee = uint64(10000000)
+    time_offset_seconds = 40
+    num_blocks_wait_in_mempool = 5
+
+    start = 100
+    end = 300
+    estimates_during = []
+    start_from = 250
+    for height in range(start, end):
+        height = uint32(height)
+        items = make_block(height, 1, cost, fee, num_blocks_wait_in_mempool)
+        estimator.new_block(FeeBlockInfo(uint32(height), items))
+        if height >= start_from:
+            estimation = estimator.estimate_fee_rate(time_offset_seconds=time_offset_seconds * (height - start_from))
+            estimates_during.append(estimation)
+
+    estimates_after = []
+    for height in range(start_from, end):
+        estimation = estimator.estimate_fee_rate(time_offset_seconds=time_offset_seconds * (height - start_from))
+        estimates_after.append(estimation)
+
+    block_estimates = [estimator.estimate_fee_rate_for_block(uint32(h + 1)) for h in range(0, 50)]
+    for idx, es_after in enumerate(estimates_after):
+        assert abs(es_after.mojos_per_clvm_cost - estimates_during[idx].mojos_per_clvm_cost) < 0.001
+        assert es_after.mojos_per_clvm_cost == block_estimates[idx].mojos_per_clvm_cost
+
+
+def test_init_buckets() -> None:
+    buckets = init_buckets()
+    assert len(buckets) > 1
+    assert buckets[0] == INITIAL_STEP
+    assert buckets[-1] == INFINITE_FEE_RATE
+
+
+def test_get_bucket_index_empty_buckets() -> None:
+    buckets: list[float] = []
+    for rate in [0.5, 1.0, 2.0]:
+        with pytest.raises(RuntimeError):
+            a = get_bucket_index(buckets, rate)
+            log.warning(a)
+
+
+def test_get_bucket_index_fee_rate_too_high() -> None:
+    buckets = [0.5, 1.0, 2.0]
+    index = get_bucket_index(buckets, 3.0)
+    assert index == len(buckets) - 1
+
+
+def test_get_bucket_index_single_entry() -> None:
+    """Test single entry with low, equal and high keys"""
+    from sys import float_info
+
+    e = float_info.epsilon * 10
+    buckets = [1.0]
+    print()
+    print(buckets)
+    for rate, expected_index in ((0.5, 0), (1.0 - e, 0), (1.5, 0)):
+        result_index = get_bucket_index(buckets, rate)
+        print(rate, expected_index, result_index)
+        assert expected_index == result_index
+
+
+def test_get_bucket_index() -> None:
+    from sys import float_info
+
+    e = float_info.epsilon * 10
+    buckets = [1.0, 2.0]
+
+    for rate, expected_index in ((0.5, 0), (1.0 - e, 0), (1.5, 0), (2.0 - e, 0), (2.0 + e, 1), (2.1, 1)):
+        result_index = get_bucket_index(buckets, rate)
+        assert result_index == expected_index
+
+
+def test_monotonically_decrease() -> None:
+    inputs: list[list[float]]
+    output: list[list[float]]
+    inputs = [[], [-1], [0], [1], [0, 0], [0, 1], [1, 0], [1, 2, 3], [1, 1, 1], [3, 2, 1], [3, 3, 1], [1, 3, 3]]
+    output = [[], [-1], [0], [1], [0, 0], [0, 0], [1, 0], [1, 1, 1], [1, 1, 1], [3, 2, 1], [3, 3, 1], [1, 1, 1]]
+    i: list[float]
+    o: list[float]
+    for i, o in zip(inputs, output):
+        print(o, i)
+        assert o == make_monotonically_decreasing(i)