chia-blockchain 2.5.8rc1__py3-none-any.whl → 2.6.0rc2__py3-none-any.whl

chia/_tests/core/mempool/test_mempool_manager.py

@@ -28,6 +28,7 @@ from chia_rs.sized_ints import uint8, uint32, uint64
 from chiabip158 import PyBIP158
 
 from chia._tests.conftest import ConsensusMode
+from chia._tests.connection_utils import add_dummy_connection, connect_and_get_peer
 from chia._tests.util.misc import Marks, datacases, invariant_check_mempool
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets, setup_simulators_and_wallets
 from chia.consensus.condition_costs import ConditionCost
@@ -55,6 +56,7 @@ from chia.full_node.mempool_manager import (
 from chia.protocols import wallet_protocol
 from chia.protocols.full_node_protocol import RequestBlock, RespondBlock
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
+from chia.server.ws_connection import WSChiaConnection
 from chia.simulator.full_node_simulator import FullNodeSimulator
 from chia.simulator.simulator_protocol import FarmNewBlockProtocol
 from chia.simulator.wallet_tools import WalletTool
@@ -67,7 +69,6 @@ from chia.types.condition_opcodes import ConditionOpcode
 from chia.types.condition_with_args import ConditionWithArgs
 from chia.types.mempool_inclusion_status import MempoolInclusionStatus
 from chia.types.mempool_item import BundleCoinSpend, MempoolItem, UnspentLineageInfo
-from chia.types.peer_info import PeerInfo
 from chia.util.casts import int_to_bytes
 from chia.util.default_root import DEFAULT_ROOT_PATH
 from chia.util.errors import Err, ValidationError
@@ -1842,9 +1843,13 @@ async def test_identical_spend_aggregation_e2e(
         }
 
     async def send_to_mempool(
-        full_node: FullNodeSimulator, spend_bundle: SpendBundle, *, expecting_conflict: bool = False
+        full_node: FullNodeSimulator,
+        wallet_peer: WSChiaConnection,
+        spend_bundle: SpendBundle,
+        *,
+        expecting_conflict: bool = False,
     ) -> None:
-        res = await full_node.send_transaction(wallet_protocol.SendTransaction(spend_bundle))
+        res = await full_node.send_transaction(wallet_protocol.SendTransaction(spend_bundle), wallet_peer)
         assert res is not None and ProtocolMessageTypes(res.type) == ProtocolMessageTypes.transaction_ack
         res_parsed = wallet_protocol.TransactionAck.from_bytes(res.data)
         if expecting_conflict:
@@ -1872,7 +1877,7 @@ async def test_identical_spend_aggregation_e2e(
             await wallet.generate_signed_transaction([uint64(200)] * len(phs), phs, action_scope)
         [tx] = action_scope.side_effects.transactions
         assert tx.spend_bundle is not None
-        await send_to_mempool(full_node_api, tx.spend_bundle)
+        await send_to_mempool(full_node_api, wallet_peer, tx.spend_bundle)
         await farm_a_block(full_node_api, wallet_node, ph)
         coins = list(await wallet_node.wallet_state_manager.coin_store.get_unspent_coins_for_wallet(1))
         # Two blocks farmed plus 3 transactions
@@ -1881,7 +1886,7 @@ async def test_identical_spend_aggregation_e2e(
 
     [[full_node_api], [[wallet_node, wallet_server]], _] = simulator_and_wallet
     server = full_node_api.full_node.server
-    await wallet_server.start_client(PeerInfo(self_hostname, server.get_port()), None)
+    wallet_peer = await connect_and_get_peer(server, wallet_server, self_hostname)
     wallet, coins, ph = await make_setup_and_coins(full_node_api, wallet_node)
 
     # Make sure spending AB then BC would generate a conflict for the latter
@@ -1896,10 +1901,10 @@ async def test_identical_spend_aggregation_e2e(
     assert tx_b.spend_bundle is not None
     assert tx_c.spend_bundle is not None
     ab_bundle = SpendBundle.aggregate([tx_a.spend_bundle, tx_b.spend_bundle])
-    await send_to_mempool(full_node_api, ab_bundle)
+    await send_to_mempool(full_node_api, wallet_peer, ab_bundle)
     # BC should conflict here (on B)
     bc_bundle = SpendBundle.aggregate([tx_b.spend_bundle, tx_c.spend_bundle])
-    await send_to_mempool(full_node_api, bc_bundle, expecting_conflict=True)
+    await send_to_mempool(full_node_api, wallet_peer, bc_bundle, expecting_conflict=True)
     await farm_a_block(full_node_api, wallet_node, ph)
 
     # Make sure DE and EF would aggregate on E when E is eligible for deduplication
@@ -1913,7 +1918,7 @@ async def test_identical_spend_aggregation_e2e(
         )
     [tx] = action_scope.side_effects.transactions
     assert tx.spend_bundle is not None
-    await send_to_mempool(full_node_api, tx.spend_bundle)
+    await send_to_mempool(full_node_api, wallet_peer, tx.spend_bundle)
     await farm_a_block(full_node_api, wallet_node, ph)
     # Grab the coin we created and make an eligible coin out of it
     coins_with_identity_ph = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(
@@ -1921,7 +1926,7 @@ async def test_identical_spend_aggregation_e2e(
     )
     coin = coins_with_identity_ph[0].coin
     sb = spend_bundle_from_conditions([[ConditionOpcode.CREATE_COIN, IDENTITY_PUZZLE_HASH, coin.amount]], coin)
-    await send_to_mempool(full_node_api, sb)
+    await send_to_mempool(full_node_api, wallet_peer, sb)
     await farm_a_block(full_node_api, wallet_node, ph)
     # Grab the eligible coin to spend as E in DE and EF transactions
     e_coin = (await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(False, IDENTITY_PUZZLE_HASH))[
@@ -1964,10 +1969,10 @@ async def test_identical_spend_aggregation_e2e(
     # Send DE and EF combinations to the mempool
     sb_de = SpendBundle.aggregate([tx_d.spend_bundle, sb_e])
     sb_de_name = sb_de.name()
-    await send_to_mempool(full_node_api, sb_de)
+    await send_to_mempool(full_node_api, wallet_peer, sb_de)
     sb_ef = SpendBundle.aggregate([sb_e, tx_f.spend_bundle])
     sb_ef_name = sb_ef.name()
-    await send_to_mempool(full_node_api, sb_ef)
+    await send_to_mempool(full_node_api, wallet_peer, sb_ef)
     # Send also a transaction EG that spends E differently from DE and EF,
     # to ensure it's rejected by the mempool
     conditions = [
@@ -1987,7 +1992,7 @@ async def test_identical_spend_aggregation_e2e(
     [tx_g] = action_scope.side_effects.transactions
     assert tx_g.spend_bundle is not None
     sb_e2g = SpendBundle.aggregate([sb_e2, tx_g.spend_bundle])
-    await send_to_mempool(full_node_api, sb_e2g, expecting_conflict=True)
+    await send_to_mempool(full_node_api, wallet_peer, sb_e2g, expecting_conflict=True)
 
     # Make sure our coin IDs to spend bundles mappings are correct
     assert get_sb_names_by_coin_id(full_node_api, coins[4].coin.name()) == {sb_de_name}
@@ -2212,6 +2217,7 @@ async def test_fill_rate_block_validation(
     max_block_clvm_cost: uint64,
     expected_block_items: int,
     expected_block_cost: uint64,
+    self_hostname: str,
 ) -> None:
     """
     This test covers the case where we set the fill rate to 100% and ensure
@@ -2222,8 +2228,10 @@ async def test_fill_rate_block_validation(
         expecting only one of the two test items to get included in the block.
     """
 
-    async def send_to_mempool(full_node: FullNodeSimulator, spend_bundle: SpendBundle) -> None:
-        res = await full_node.send_transaction(wallet_protocol.SendTransaction(spend_bundle))
+    async def send_to_mempool(
+        full_node: FullNodeSimulator, dummy_peer: WSChiaConnection, spend_bundle: SpendBundle
+    ) -> None:
+        res = await full_node.send_transaction(wallet_protocol.SendTransaction(spend_bundle), dummy_peer)
         assert res is not None and ProtocolMessageTypes(res.type) == ProtocolMessageTypes.transaction_ack
         res_parsed = wallet_protocol.TransactionAck.from_bytes(res.data)
         assert res_parsed.status == MempoolInclusionStatus.SUCCESS.value
@@ -2242,11 +2250,13 @@ async def test_fill_rate_block_validation(
             coin_records = await full_node_api.full_node.coin_store.get_coin_records_by_puzzle_hash(False, ph)
             coin = next(cr.coin for cr in coin_records if cr.coin.amount == 250_000_000_000)
             coins_and_puzzles.append((coin, puzzle))
+        _, dummy_node_id = await add_dummy_connection(full_node_api.server, self_hostname, 12312)
+        dummy_peer = full_node_api.server.all_connections[dummy_node_id]
         sbs_info = []
         for coin, puzzle in coins_and_puzzles:
             coin_spend = make_spend(coin, puzzle, SerializedProgram.to([]))
             sb = SpendBundle([coin_spend], G2Element())
-            await send_to_mempool(full_node_api, sb)
+            await send_to_mempool(full_node_api, dummy_peer, sb)
             sbs_info.append((coin.name(), puzzle, sb.name()))
         return sbs_info
 

chia/_tests/util/test_replace_str_to_bytes.py

@@ -59,6 +59,7 @@ test_constants = ConsensusConstants(
     POOL_SUB_SLOT_ITERS=uint64(37600000000),
     HARD_FORK_HEIGHT=uint32(5496000),
     HARD_FORK2_HEIGHT=uint32(0xFFFFFFFF),
+    SOFT_FORK8_HEIGHT=uint32(8655000),
     PLOT_V1_PHASE_OUT_EPOCH_BITS=uint8(8),
     PLOT_FILTER_128_HEIGHT=uint32(10542000),
     PLOT_FILTER_64_HEIGHT=uint32(15592000),

chia/_tests/util/test_testnet_overrides.py

@@ -8,19 +8,19 @@ from chia.consensus.default_constants import update_testnet_overrides
 def test_testnet11() -> None:
     overrides: dict[str, Any] = {}
     update_testnet_overrides("testnet11", overrides)
-    assert overrides == {"PLOT_SIZE_V2": 28}
+    assert overrides == {"PLOT_SIZE_V2": 28, "SOFT_FORK8_HEIGHT": 3680000}
 
 
 def test_min_plot_size() -> None:
     overrides: dict[str, Any] = {"MIN_PLOT_SIZE": 18}
     update_testnet_overrides("testnet11", overrides)
-    assert overrides == {"MIN_PLOT_SIZE_V1": 18, "PLOT_SIZE_V2": 28}
+    assert overrides == {"MIN_PLOT_SIZE_V1": 18, "PLOT_SIZE_V2": 28, "SOFT_FORK8_HEIGHT": 3680000}
 
 
 def test_max_plot_size() -> None:
     overrides: dict[str, Any] = {"MAX_PLOT_SIZE": 32}
     update_testnet_overrides("testnet11", overrides)
-    assert overrides == {"MAX_PLOT_SIZE_V1": 32, "PLOT_SIZE_V2": 28}
+    assert overrides == {"MAX_PLOT_SIZE_V1": 32, "PLOT_SIZE_V2": 28, "SOFT_FORK8_HEIGHT": 3680000}
 
 
 def test_mainnet() -> None:

chia/_tests/wallet/sync/test_wallet_sync.py

@@ -25,7 +25,12 @@ from chiabip158 import PyBIP158
 from colorlog import getLogger
 
 from chia._tests.conftest import ConsensusMode
-from chia._tests.connection_utils import connect_and_get_peer, disconnect_all, disconnect_all_and_reconnect
+from chia._tests.connection_utils import (
+    add_dummy_connection,
+    connect_and_get_peer,
+    disconnect_all,
+    disconnect_all_and_reconnect,
+)
 from chia._tests.util.blockchain_mock import BlockchainMock
 from chia._tests.util.misc import patch_request_handler, wallet_height_at_least
 from chia._tests.util.setup_nodes import OldSimulatorsAndWallets
@@ -676,7 +681,7 @@ async def test_request_additions_success(simulator_and_wallet: OldSimulatorsAndW
         ph = await action_scope.get_puzzle_hash(wallet.wallet_state_manager)
 
     full_node_api = full_nodes[0]
-    await wallet_server.start_client(PeerInfo(self_hostname, full_node_api.full_node.server.get_port()), None)
+    wallet_peer = await connect_and_get_peer(full_node_api.full_node.server, wallet_server, self_hostname)
 
     for _ in range(2):
         await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
@@ -698,7 +703,7 @@ async def test_request_additions_success(simulator_and_wallet: OldSimulatorsAndW
         )
     [tx] = action_scope.side_effects.transactions
     assert tx.spend_bundle is not None
-    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle))
+    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle), wallet_peer)
     await full_node_api.wait_transaction_records_entered_mempool([tx])
     await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
 
@@ -918,7 +923,9 @@ async def test_dusted_wallet(
         )
     [tx] = action_scope.side_effects.transactions
     assert tx.spend_bundle is not None
-    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle))
+    _, dummy_node_id = await add_dummy_connection(full_node_api.server, self_hostname, 12312)
+    dummy_peer = full_node_api.server.all_connections[dummy_node_id]
+    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle), dummy_peer)
     await full_node_api.wait_transaction_records_entered_mempool([tx])
     await full_node_api.wait_for_wallets_synced(wallet_nodes=[farm_wallet_node, dust_wallet_node], timeout=20)
     await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
@@ -985,7 +992,7 @@ async def test_dusted_wallet(
                 )
             [tx] = action_scope.side_effects.transactions
             assert tx.spend_bundle is not None
-            await full_node_api.send_transaction(SendTransaction(tx.spend_bundle))
+            await full_node_api.send_transaction(SendTransaction(tx.spend_bundle), dummy_peer)
 
             # advance the chain and sync both wallets
             await full_node_api.wait_transaction_records_entered_mempool([tx])
@@ -1008,7 +1015,7 @@ async def test_dusted_wallet(
             )
         [tx] = action_scope.side_effects.transactions
         assert tx.spend_bundle is not None
-        await full_node_api.send_transaction(SendTransaction(tx.spend_bundle))
+        await full_node_api.send_transaction(SendTransaction(tx.spend_bundle), dummy_peer)
 
         # advance the chain and sync both wallets
         await full_node_api.wait_transaction_records_entered_mempool([tx])
@@ -1061,7 +1068,7 @@ async def test_dusted_wallet(
         )
     [tx] = action_scope.side_effects.transactions
     assert tx.spend_bundle is not None
-    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle))
+    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle), dummy_peer)
 
     # advance the chain and sync both wallets
     await full_node_api.wait_transaction_records_entered_mempool([tx])
@@ -1105,7 +1112,7 @@ async def test_dusted_wallet(
         )
     [tx] = action_scope.side_effects.transactions
     assert tx.spend_bundle is not None
-    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle))
+    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle), dummy_peer)
 
     # advance the chain and sync both wallets
     await full_node_api.wait_transaction_records_entered_mempool([tx])
@@ -1169,7 +1176,7 @@ async def test_dusted_wallet(
         )
     [tx] = action_scope.side_effects.transactions
     assert tx.spend_bundle is not None
-    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle))
+    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle), dummy_peer)
 
     # advance the chain and sync both wallets
     await full_node_api.wait_transaction_records_entered_mempool([tx])
@@ -1210,7 +1217,7 @@ async def test_dusted_wallet(
         )
     [tx] = action_scope.side_effects.transactions
     assert tx.spend_bundle is not None
-    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle))
+    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle), dummy_peer)
 
     # advance the chain and sync both wallets
     await full_node_api.wait_transaction_records_entered_mempool([tx])
@@ -1259,7 +1266,7 @@ async def test_dusted_wallet(
                 )
             [tx] = action_scope.side_effects.transactions
             assert tx.spend_bundle is not None
-            await full_node_api.send_transaction(SendTransaction(tx.spend_bundle))
+            await full_node_api.send_transaction(SendTransaction(tx.spend_bundle), dummy_peer)
             await full_node_api.wait_transaction_records_entered_mempool([tx])
             await full_node_api.wait_for_wallets_synced(wallet_nodes=[farm_wallet_node, dust_wallet_node], timeout=20)
             await full_node_api.farm_new_transaction_block(FarmNewBlockProtocol(ph))
@@ -1278,7 +1285,7 @@ async def test_dusted_wallet(
         )
     [tx] = action_scope.side_effects.transactions
     assert tx.spend_bundle is not None
-    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle))
+    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle), dummy_peer)
 
     # advance the chain and sync both wallets
     await full_node_api.wait_transaction_records_entered_mempool([tx])
@@ -1313,7 +1320,7 @@ async def test_dusted_wallet(
         )
     [tx] = action_scope.side_effects.transactions
     assert tx.spend_bundle is not None
-    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle))
+    await full_node_api.send_transaction(SendTransaction(tx.spend_bundle), dummy_peer)
 
     # advance the chain and sync both wallets
     await full_node_api.wait_transaction_records_entered_mempool([tx])

chia/_tests/wallet/test_new_wallet_protocol.py

@@ -833,7 +833,7 @@ async def raw_mpu_setup(one_node: OneNode, self_hostname: str, no_capability: bo
     for coin, hint in new_coins:
         solution = Program.to([[]])
         bundle = SpendBundle([CoinSpend(coin, puzzle, solution)], AugSchemeMPL.aggregate([]))
-        tx_resp = await simulator.send_transaction(wallet_protocol.SendTransaction(bundle))
+        tx_resp = await simulator.send_transaction(wallet_protocol.SendTransaction(bundle), peer)
         assert tx_resp is not None
 
         ack = wallet_protocol.TransactionAck.from_bytes(tx_resp.data)
@@ -891,11 +891,13 @@ async def subscribe_puzzle(
     assert len(response.coin_states) == existing_coin_states
 
 
-async def spend_coin(simulator: FullNodeSimulator, coin: Coin, solution: Program | None = None) -> bytes32:
+async def spend_coin(
+    simulator: FullNodeSimulator, peer: WSChiaConnection, coin: Coin, solution: Program | None = None
+) -> bytes32:
     bundle = SpendBundle(
         [CoinSpend(coin, IDENTITY_PUZZLE, Program.to([]) if solution is None else solution)], AugSchemeMPL.aggregate([])
     )
-    tx_resp = await simulator.send_transaction(wallet_protocol.SendTransaction(bundle))
+    tx_resp = await simulator.send_transaction(wallet_protocol.SendTransaction(bundle), peer)
     assert tx_resp is not None
 
     ack = wallet_protocol.TransactionAck.from_bytes(tx_resp.data)
@@ -915,7 +917,7 @@ async def test_spent_coin_id_mempool_update(mpu_setup: Mpu) -> None:
     # Make a coin and spend it
     coin, _ = await make_coin(simulator.full_node)
     await subscribe_coin(simulator, coin.name(), peer)
-    transaction_id = await spend_coin(simulator, coin)
+    transaction_id = await spend_coin(simulator, peer, coin)
 
     # We should have gotten a mempool update for this transaction
     await assert_mempool_added(queue, {transaction_id})
@@ -942,7 +944,7 @@ async def test_spent_puzzle_hash_mempool_update(mpu_setup: Mpu) -> None:
     # Make a coin and spend it
     coin, _ = await make_coin(simulator.full_node)
     await subscribe_puzzle(simulator, coin.puzzle_hash, peer)
-    transaction_id = await spend_coin(simulator, coin)
+    transaction_id = await spend_coin(simulator, peer, coin)
 
     # We should have gotten a mempool update for this transaction
     await assert_mempool_added(queue, {transaction_id})
@@ -969,7 +971,7 @@ async def test_spent_hint_mempool_update(mpu_setup: Mpu) -> None:
     # Make a coin and spend it
     coin, hint = await make_coin(simulator.full_node)
     await subscribe_puzzle(simulator, hint, peer)
-    transaction_id = await spend_coin(simulator, coin)
+    transaction_id = await spend_coin(simulator, peer, coin)
 
     # We should have gotten a mempool update for this transaction
     await assert_mempool_added(queue, {transaction_id})
@@ -998,7 +1000,7 @@ async def test_created_coin_id_mempool_update(mpu_setup: Mpu) -> None:
     child_coin = Coin(coin.name(), std_hash(b"new puzzle hash"), coin.amount)
     await subscribe_coin(simulator, child_coin.name(), peer, existing_coin_states=0)
     transaction_id = await spend_coin(
-        simulator, coin, solution=Program.to([[51, child_coin.puzzle_hash, child_coin.amount]])
+        simulator, peer, coin, solution=Program.to([[51, child_coin.puzzle_hash, child_coin.amount]])
     )
 
     # We should have gotten a mempool update for this transaction
@@ -1028,7 +1030,7 @@ async def test_created_puzzle_hash_mempool_update(mpu_setup: Mpu) -> None:
     child_coin = Coin(coin.name(), std_hash(b"new puzzle hash"), coin.amount)
     await subscribe_puzzle(simulator, child_coin.puzzle_hash, peer, existing_coin_states=0)
     transaction_id = await spend_coin(
-        simulator, coin, solution=Program.to([[51, child_coin.puzzle_hash, child_coin.amount]])
+        simulator, peer, coin, solution=Program.to([[51, child_coin.puzzle_hash, child_coin.amount]])
     )
 
     # We should have gotten a mempool update for this transaction
@@ -1059,7 +1061,7 @@ async def test_created_hint_mempool_update(mpu_setup: Mpu) -> None:
     hint = std_hash(b"new hint")
     await subscribe_puzzle(simulator, hint, peer, existing_coin_states=0)
     transaction_id = await spend_coin(
-        simulator, coin, solution=Program.to([[51, child_coin.puzzle_hash, child_coin.amount, [hint]]])
+        simulator, peer, coin, solution=Program.to([[51, child_coin.puzzle_hash, child_coin.amount, [hint]]])
     )
 
     # We should have gotten a mempool update for this transaction
@@ -1087,7 +1089,7 @@ async def test_missing_capability_coin_id(mpu_setup_no_capability: Mpu) -> None:
     # Make a coin and spend it
     coin, _ = await make_coin(simulator.full_node)
     await subscribe_coin(simulator, coin.name(), peer)
-    transaction_id = await spend_coin(simulator, coin)
+    transaction_id = await spend_coin(simulator, peer, coin)
 
     # There is no mempool update for this transaction since the peer doesn't have the capability
     assert queue.empty()
@@ -1112,7 +1114,7 @@ async def test_missing_capability_puzzle_hash(mpu_setup_no_capability: Mpu) -> N
     # Make a coin and spend it
     coin, _ = await make_coin(simulator.full_node)
     await subscribe_puzzle(simulator, coin.puzzle_hash, peer)
-    transaction_id = await spend_coin(simulator, coin)
+    transaction_id = await spend_coin(simulator, peer, coin)
 
     # There is no mempool update for this transaction since the peer doesn't have the capability
     assert queue.empty()
@@ -1137,7 +1139,7 @@ async def test_missing_capability_hint(mpu_setup_no_capability: Mpu) -> None:
     # Make a coin and spend it
     coin, hint = await make_coin(simulator.full_node)
     await subscribe_puzzle(simulator, hint, peer)
-    transaction_id = await spend_coin(simulator, coin)
+    transaction_id = await spend_coin(simulator, peer, coin)
 
     # There is no mempool update for this transaction since the peer doesn't have the capability
     assert queue.empty()

chia/_tests/wallet/test_wallet_node.py

@@ -19,6 +19,7 @@ from chia.protocols import wallet_protocol
 from chia.protocols.outbound_message import Message, make_msg
 from chia.protocols.protocol_message_types import ProtocolMessageTypes
 from chia.server.api_protocol import Self
+from chia.server.ws_connection import WSChiaConnection
 from chia.simulator.add_blocks_in_batches import add_blocks_in_batches
 from chia.simulator.block_tools import test_constants
 from chia.types.blockchain_format.coin import Coin
@@ -624,7 +625,7 @@ async def test_transaction_send_cache(
     logged_spends = []
 
     async def send_transaction(
-        self: Self, request: wallet_protocol.SendTransaction, *, test: bool = False
+        self: Self, request: wallet_protocol.SendTransaction, peer: WSChiaConnection, *, test: bool = False
     ) -> Message | None:
         logged_spends.append(request.transaction.name())
         return None

chia/apis/full_node_stub.py

@@ -285,8 +285,10 @@ class FullNodeApiStub(ApiProtocol, Protocol):
         """Handle removals request from wallet."""
         ...
 
-    @metadata.request()
-    async def send_transaction(self, request: wallet_protocol.SendTransaction, *, test: bool = False) -> Message | None:
+    @metadata.request(peer_required=True)
+    async def send_transaction(
+        self, request: wallet_protocol.SendTransaction, peer: WSChiaConnection, *, test: bool = False
+    ) -> Message | None:
         """Handle transaction send from wallet."""
         ...
 

chia/consensus/block_header_validation.py

@@ -510,7 +510,7 @@ def validate_unfinished_header_block(
             blocks=blocks,
             prev_b_hash=header_block.prev_header_hash,
             sp_index=header_block.reward_chain_block.signage_point_index,
-            first_in_sub_slot=len(header_block.finished_sub_slots) > 0,
+            finished_sub_slots=len(header_block.finished_sub_slots),
         ),
     )
     if required_iters is None:

chia/consensus/blockchain.py

@@ -279,7 +279,7 @@ class Blockchain:
                 blocks=self,
                 prev_b_hash=block.prev_header_hash,
                 sp_index=block.reward_chain_block.signage_point_index,
-                first_in_sub_slot=len(block.finished_sub_slots) > 0,
+                finished_sub_slots=len(block.finished_sub_slots),
             )
             flags = get_flags_for_height_and_constants(prev_tx_height, self.constants)
             additions, removals = additions_and_removals(
@@ -715,7 +715,7 @@ class Blockchain:
             blocks=self,
             prev_b_hash=block.prev_header_hash,
             sp_index=block.reward_chain_block.signage_point_index,
-            first_in_sub_slot=len(block.finished_sub_slots) > 0,
+            finished_sub_slots=len(block.finished_sub_slots),
         )
 
         # With hard fork 2 we ban transactions_generator_ref_list.

chia/consensus/default_constants.py

@@ -81,6 +81,7 @@ DEFAULT_CONSTANTS = ConsensusConstants(
     HARD_FORK_HEIGHT=uint32(5496000),
     # TODO: todo_v2_plots finalize fork height
     HARD_FORK2_HEIGHT=uint32(0xFFFFFFFA),
+    SOFT_FORK8_HEIGHT=uint32(8655000),
     # starting at the hard fork 2 height, v1 plots will gradually be phased out,
     # and stop working entirely after (1 << this) many epochs
     PLOT_V1_PHASE_OUT_EPOCH_BITS=uint8(8),
@@ -111,6 +112,8 @@ def update_testnet_overrides(network_id: str, overrides: dict[str, Any]) -> None
     if network_id in {"testnet11", "testneta"}:
         if "PLOT_SIZE_V2" not in overrides:
             overrides["PLOT_SIZE_V2"] = 28
+        if "SOFT_FORK8_HEIGHT" not in overrides:
+            overrides["SOFT_FORK8_HEIGHT"] = 3680000
     if network_id == "testneta":
         if "HARD_FORK_HEIGHT" not in overrides:
             overrides["HARD_FORK_HEIGHT"] = 3693395

chia/consensus/get_block_challenge.py

@@ -7,6 +7,7 @@ from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint8, uint32, uint64
 
 from chia.consensus.blockchain_interface import BlockRecordsProtocol
+from chia.consensus.pot_iterations import is_overflow_block
 from chia.types.unfinished_header_block import UnfinishedHeaderBlock
 
 log = logging.getLogger(__name__)
@@ -110,17 +111,24 @@ def pre_sp_tx_block(
     *,
     prev_b_hash: bytes32,
     sp_index: uint8,
-    first_in_sub_slot: bool,
+    finished_sub_slots: int,
 ) -> BlockRecord | None:
     if prev_b_hash == constants.GENESIS_CHALLENGE:
         return None
     curr = blocks.block_record(prev_b_hash)
-    before_slot = first_in_sub_slot
+    # For overflow blocks, the SP is in the previous sub-slot, so we need to cross
+    # one extra slot boundary before we're past the SP's slot
+    overflow = is_overflow_block(constants, sp_index)
+    slots_crossed = finished_sub_slots
     while curr.height > 0:
-        if curr.is_transaction_block and (before_slot or curr.signage_point_index < sp_index):
+        if not overflow:
+            before_sp = curr.signage_point_index < sp_index or slots_crossed > 0
+        else:
+            before_sp = slots_crossed >= 2 or (slots_crossed == 1 and curr.signage_point_index < sp_index)
+        if curr.is_transaction_block and before_sp:
             break
         if curr.first_in_sub_slot:
-            before_slot = True
+            slots_crossed += 1
         curr = blocks.block_record(curr.prev_hash)
     return curr
 
@@ -131,14 +139,14 @@ def pre_sp_tx_block_height(
     *,
     prev_b_hash: bytes32,
     sp_index: uint8,
-    first_in_sub_slot: bool,
+    finished_sub_slots: int,
 ) -> uint32:
     latest_tx_block = pre_sp_tx_block(
         constants=constants,
         blocks=blocks,
         prev_b_hash=prev_b_hash,
         sp_index=sp_index,
-        first_in_sub_slot=first_in_sub_slot,
+        finished_sub_slots=finished_sub_slots,
     )
     if latest_tx_block is None:
         return uint32(0)

chia/consensus/multiprocess_validation.py

@@ -120,7 +120,7 @@ def _pre_validate_block(
                 blocks=blockchain,
                 prev_b_hash=block.prev_header_hash,
                 sp_index=block.reward_chain_block.signage_point_index,
-                first_in_sub_slot=len(block.finished_sub_slots) > 0,
+                finished_sub_slots=len(block.finished_sub_slots),
             )
             err, conds = _run_block(block, prev_generators, prev_tx_height, constants)
 
@@ -231,7 +231,7 @@ async def pre_validate_block(
             blocks=blockchain,
             prev_b_hash=block.prev_header_hash,
             sp_index=block.reward_chain_block.signage_point_index,
-            first_in_sub_slot=len(block.finished_sub_slots) > 0,
+            finished_sub_slots=len(block.finished_sub_slots),
         ),
     )
     if required_iters is None:

chia/full_node/full_node.py

@@ -286,7 +286,9 @@ class FullNode:
                 single_threaded=single_threaded,
             ) as self._mempool_manager:
                 # Transactions go into this queue from the server, and get sent to respond_transaction
-                self._transaction_queue = TransactionQueue(1000, self.log)
+                self._transaction_queue = TransactionQueue(
+                    1000, self.log, max_tx_clvm_cost=uint64(self.constants.MAX_BLOCK_COST_CLVM // 2)
+                )
                 self._transaction_queue_task: asyncio.Task[None] = create_referenced_task(self._handle_transactions())
 
                 self._init_weight_proof = create_referenced_task(self.initialize_weight_proof())

chia/full_node/full_node_api.py

@@ -38,13 +38,13 @@ from chiabip158 import PyBIP158
 from chia.consensus.block_creation import create_unfinished_block
 from chia.consensus.blockchain import BlockchainMutexPriority
 from chia.consensus.generator_tools import get_block_header
-from chia.consensus.get_block_challenge import pre_sp_tx_block_height
 from chia.consensus.get_block_generator import get_block_generator
 from chia.consensus.pot_iterations import calculate_ip_iters, calculate_iterations_quality, calculate_sp_iters
 from chia.consensus.signage_point import SignagePoint
 from chia.full_node.coin_store import CoinStore
 from chia.full_node.fee_estimator_interface import FeeEstimatorInterface
 from chia.full_node.full_block_utils import get_height_and_tx_status_from_block, header_block_from_block
+from chia.full_node.hard_fork_utils import get_flags
 from chia.full_node.tx_processing_queue import PeerWithTx, TransactionQueueEntry, TransactionQueueFull
 from chia.protocols import farmer_protocol, full_node_protocol, introducer_protocol, timelord_protocol, wallet_protocol
 from chia.protocols.fee_estimate import FeeEstimate, FeeEstimateGroup, fee_rate_v2_to_v1
@@ -1270,15 +1270,7 @@ class FullNodeAPI:
             # in this case we've already made sure `block` does have a
             # transactions_generator, so the block_generator should always be set
             assert block_generator is not None, "failed to get block_generator for tx-block"
-
-            prev_tx_height = pre_sp_tx_block_height(
-                constants=self.full_node.constants,
-                blocks=self.full_node.blockchain,
-                prev_b_hash=block.prev_header_hash,
-                sp_index=block.reward_chain_block.signage_point_index,
-                first_in_sub_slot=len(block.finished_sub_slots) > 0,
-            )
-            flags = get_flags_for_height_and_constants(prev_tx_height, self.full_node.constants)
+            flags = await get_flags(constants=self.full_node.constants, blocks=self.full_node.blockchain, block=block)
             additions, removals = await asyncio.get_running_loop().run_in_executor(
                 self.executor,
                 additions_and_removals,
@@ -1424,16 +1416,26 @@ class FullNodeAPI:
         msg = make_msg(ProtocolMessageTypes.respond_removals, response)
         return msg
 
-    @metadata.request()
-    async def send_transaction(self, request: wallet_protocol.SendTransaction, *, test: bool = False) -> Message | None:
+    @metadata.request(peer_required=True)
+    async def send_transaction(
+        self, request: wallet_protocol.SendTransaction, peer: WSChiaConnection, *, test: bool = False
+    ) -> Message | None:
         spend_name = request.transaction.name()
         if self.full_node.mempool_manager.get_spendbundle(spend_name) is not None:
             self.full_node.mempool_manager.remove_seen(spend_name)
             response = wallet_protocol.TransactionAck(spend_name, uint8(MempoolInclusionStatus.SUCCESS), None)
             return make_msg(ProtocolMessageTypes.transaction_ack, response)
-
+        high_priority = self.is_trusted(peer)
         queue_entry = TransactionQueueEntry(request.transaction, None, spend_name, None, test)
-        self.full_node.transaction_queue.put(queue_entry, peer_id=None, high_priority=True)
+        try:
+            self.full_node.transaction_queue.put(queue_entry, peer_id=peer.peer_node_id, high_priority=high_priority)
+        except TransactionQueueFull:
+            return make_msg(
+                ProtocolMessageTypes.transaction_ack,
+                wallet_protocol.TransactionAck(
+                    spend_name, uint8(MempoolInclusionStatus.FAILED), "Transaction queue full"
+                ),
+            )
         try:
             with anyio.fail_after(delay=45):
                 status, error = await queue_entry.done.wait()