chia-blockchain 2.5.4rc2__py3-none-any.whl → 2.5.5__py3-none-any.whl

chia/_tests/core/full_node/stores/test_coin_store.py

@@ -5,31 +5,31 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Optional
 
+import aiosqlite
 import pytest
+from chia_rs import CoinState, FullBlock, additions_and_removals, get_flags_for_height_and_constants
 from chia_rs.sized_bytes import bytes32
 from chia_rs.sized_ints import uint32, uint64
-from clvm.casts import int_to_bytes
 
 from chia._tests.blockchain.blockchain_test_utils import _validate_and_add_block
+from chia._tests.util.coin_store import add_coin_records_to_db
 from chia._tests.util.db_connection import DBConnection
-from chia._tests.util.get_name_puzzle_conditions import get_name_puzzle_conditions
 from chia._tests.util.misc import Marks, datacases
 from chia.consensus.block_body_validation import ForkInfo
 from chia.consensus.block_rewards import calculate_base_farmer_reward, calculate_pool_reward
 from chia.consensus.blockchain import AddBlockResult, Blockchain
 from chia.consensus.coinbase import create_farmer_coin, create_pool_coin
+from chia.full_node.block_height_map import BlockHeightMap
 from chia.full_node.block_store import BlockStore
 from chia.full_node.coin_store import CoinStore
 from chia.full_node.hint_store import HintStore
-from chia.protocols.wallet_protocol import CoinState
 from chia.simulator.block_tools import BlockTools, test_constants
 from chia.simulator.wallet_tools import WalletTool
 from chia.types.blockchain_format.coin import Coin
 from chia.types.coin_record import CoinRecord
-from chia.types.eligible_coin_spends import UnspentLineageInfo
-from chia.types.full_block import FullBlock
-from chia.types.generator_types import BlockGenerator
-from chia.util.generator_tools import tx_removals_and_additions
+from chia.types.mempool_item import UnspentLineageInfo
+from chia.util.casts import int_to_bytes
+from chia.util.db_wrapper import DBWrapper2
 from chia.util.hash import std_hash
 
 constants = test_constants
@@ -98,75 +98,73 @@ async def test_basic_coin_store(db_version: int, softfork_height: uint32, bt: Bl
             farmer_coin, pool_coin = get_future_reward_coins(block)
             should_be_included.add(farmer_coin)
             should_be_included.add(pool_coin)
-            if block.is_transaction_block():
-                if block.transactions_generator is not None:
-                    assert block.transactions_info is not None
-                    block_gen: BlockGenerator = BlockGenerator(block.transactions_generator, [])
-                    npc_result = get_name_puzzle_conditions(
-                        block_gen,
-                        bt.constants.MAX_BLOCK_COST_CLVM,
-                        mempool_mode=False,
-                        height=softfork_height,
-                        constants=bt.constants,
-                    )
-                    tx_removals, tx_additions = tx_removals_and_additions(npc_result.conds)
-                else:
-                    tx_removals, tx_additions = [], []
-
-                assert set(block.get_included_reward_coins()) == should_be_included_prev
+            if not block.is_transaction_block():
+                continue
+            if block.transactions_generator is not None:
+                assert block.transactions_info is not None
+                flags = get_flags_for_height_and_constants(block.height, bt.constants)
+                additions, removals = additions_and_removals(
+                    bytes(block.transactions_generator), [], flags, bt.constants
+                )
+                tx_removals = [name for name, _ in removals]
+                tx_additions = [(addition.name(), addition, False) for addition, _ in additions]
+            else:
+                tx_removals, tx_additions = [], []
+
+            reward_coins = block.get_included_reward_coins()
+            assert set(reward_coins) == should_be_included_prev
+
+            assert block.foliage_transaction_block is not None
+            await coin_store.new_block(
+                block.height,
+                block.foliage_transaction_block.timestamp,
+                reward_coins,
+                tx_additions,
+                tx_removals,
+            )
 
-                if block.is_transaction_block():
-                    assert block.foliage_transaction_block is not None
+            if block.height != 0:
+                with pytest.raises(Exception):
                     await coin_store.new_block(
                         block.height,
                         block.foliage_transaction_block.timestamp,
-                        block.get_included_reward_coins(),
+                        reward_coins,
                         tx_additions,
                         tx_removals,
                     )
 
-                    if block.height != 0:
-                        with pytest.raises(Exception):
-                            await coin_store.new_block(
-                                block.height,
-                                block.foliage_transaction_block.timestamp,
-                                block.get_included_reward_coins(),
-                                tx_additions,
-                                tx_removals,
-                            )
-
-                all_records = set()
-                for expected_coin in should_be_included_prev:
-                    # Check that the coinbase rewards are added
-                    record = await coin_store.get_coin_record(expected_coin.name())
-                    assert record is not None
-                    assert not record.spent
-                    assert record.coin == expected_coin
-                    all_records.add(record)
-                for coin_name in tx_removals:
-                    # Check that the removed coins are set to spent
-                    record = await coin_store.get_coin_record(coin_name)
-                    assert record is not None
-                    assert record.spent
-                    all_records.add(record)
-                for coin in tx_additions:
-                    # Check that the added coins are added
-                    record = await coin_store.get_coin_record(coin.name())
-                    assert record is not None
-                    assert not record.spent
-                    assert coin == record.coin
-                    all_records.add(record)
-
-                db_records = await coin_store.get_coin_records(
-                    [c.name() for c in list(should_be_included_prev) + tx_additions] + tx_removals
-                )
-                assert len(db_records) == len(should_be_included_prev) + len(tx_removals) + len(tx_additions)
-                assert len(db_records) == len(all_records)
-                for record in db_records:
-                    assert record in all_records
+            all_records = set()
+            for expected_coin in should_be_included_prev:
+                # Check that the coinbase rewards are added
+                record = await coin_store.get_coin_record(expected_coin.name())
+                assert record is not None
+                assert not record.spent
+                assert record.coin == expected_coin
+                all_records.add(record)
+            for coin_name in tx_removals:
+                # Check that the removed coins are set to spent
+                record = await coin_store.get_coin_record(coin_name)
+                assert record is not None
+                assert record.spent
+                all_records.add(record)
+            for coin_id, coin, _ in tx_additions:
+                # Check that the added coins are added
+                record = await coin_store.get_coin_record(coin_id)
+                assert record is not None
+                assert not record.spent
+                assert coin == record.coin
+                all_records.add(record)
+
+            db_records = await coin_store.get_coin_records(
+                [c.name() for c in should_be_included_prev] + [coin_id for coin_id, _, _ in tx_additions] + tx_removals
+            )
+            assert len(db_records) == len(should_be_included_prev) + len(tx_removals) + len(tx_additions)
+            assert len(db_records) == len(all_records)
+            for record in db_records:
+                assert record in all_records
 
-                should_be_included_prev = should_be_included.copy()
-                should_be_included = set()
+            should_be_included_prev = should_be_included.copy()
+            should_be_included = set()
 
 
 @pytest.mark.limit_consensus_modes(reason="save time")
@@ -179,39 +177,31 @@ async def test_set_spent(db_version: int, bt: BlockTools) -> None:
 
         # Save/get block
         for block in blocks:
-            if block.is_transaction_block():
-                removals: list[bytes32] = []
-                additions: list[Coin] = []
-                async with db_wrapper.writer():
-                    if block.is_transaction_block():
-                        assert block.foliage_transaction_block is not None
-                        await coin_store.new_block(
-                            block.height,
-                            block.foliage_transaction_block.timestamp,
-                            block.get_included_reward_coins(),
-                            additions,
-                            removals,
-                        )
-
-                    coins = block.get_included_reward_coins()
-                    records = [await coin_store.get_coin_record(coin.name()) for coin in coins]
+            if not block.is_transaction_block():
+                continue
+            assert block.foliage_transaction_block is not None
+            await coin_store.new_block(
+                block.height, block.foliage_transaction_block.timestamp, block.get_included_reward_coins(), [], []
+            )
+            coins = block.get_included_reward_coins()
+            records = [await coin_store.get_coin_record(coin.name()) for coin in coins]
 
-                await coin_store._set_spent([r.name for r in records if r is not None], block.height)
+            await coin_store._set_spent([r.name for r in records if r is not None], block.height)
 
-                if len(records) > 0:
-                    for r in records:
-                        assert r is not None
-                        assert (await coin_store.get_coin_record(r.name)) is not None
+            if len(records) > 0:
+                for r in records:
+                    assert r is not None
+                    assert (await coin_store.get_coin_record(r.name)) is not None
 
-                    # Check that we can't spend a coin twice in DB
-                    with pytest.raises(ValueError, match="Invalid operation to set spent"):
-                        await coin_store._set_spent([r.name for r in records if r is not None], block.height)
+                # Check that we can't spend a coin twice in DB
+                with pytest.raises(ValueError, match="Invalid operation to set spent"):
+                    await coin_store._set_spent([r.name for r in records if r is not None], block.height)
 
-                records = [await coin_store.get_coin_record(coin.name()) for coin in coins]
-                for record in records:
-                    assert record is not None
-                    assert record.spent
-                    assert record.spent_block_index == block.height
+            records = [await coin_store.get_coin_record(coin.name()) for coin in coins]
+            for record in records:
+                assert record is not None
+                assert record.spent
+                assert record.spent_block_index == block.height
 
 
 @pytest.mark.limit_consensus_modes(reason="save time")
@@ -228,22 +218,12 @@ async def test_num_unspent(bt: BlockTools, db_version: int) -> None:
         for block in blocks:
             if not block.is_transaction_block():
                 continue
-
-            if block.is_transaction_block():
-                assert block.foliage_transaction_block is not None
-                removals: list[bytes32] = []
-                additions: list[Coin] = []
-                await coin_store.new_block(
-                    block.height,
-                    block.foliage_transaction_block.timestamp,
-                    block.get_included_reward_coins(),
-                    additions,
-                    removals,
-                )
-
-                expect_unspent += len(block.get_included_reward_coins())
-                assert await coin_store.num_unspent() == expect_unspent
-                test_excercised = expect_unspent > 0
+            assert block.foliage_transaction_block is not None
+            reward_coins = block.get_included_reward_coins()
+            await coin_store.new_block(block.height, block.foliage_transaction_block.timestamp, reward_coins, [], [])
+            expect_unspent += len(reward_coins)
+            assert await coin_store.num_unspent() == expect_unspent
+            test_excercised = expect_unspent > 0
 
     assert test_excercised
 
@@ -260,48 +240,41 @@ async def test_rollback(db_version: int, bt: BlockTools) -> None:
         all_coins: list[Coin] = []
 
         for block in blocks:
-            all_coins += list(block.get_included_reward_coins())
-            if block.is_transaction_block():
-                removals: list[bytes32] = []
-                additions: list[Coin] = []
-                assert block.foliage_transaction_block is not None
-                await coin_store.new_block(
-                    block.height,
-                    block.foliage_transaction_block.timestamp,
-                    block.get_included_reward_coins(),
-                    additions,
-                    removals,
-                )
-                coins = block.get_included_reward_coins()
-                records = [await coin_store.get_coin_record(coin.name()) for coin in coins]
-
-                spend_selected_coin = selected_coin is not None
-                if block.height != 0 and selected_coin is None:
-                    # Select the first CoinRecord which will be spent at the next transaction block.
-                    selected_coin = records[0]
-                    await coin_store._set_spent([r.name for r in records[1:] if r is not None], block.height)
-                else:
-                    await coin_store._set_spent([r.name for r in records if r is not None], block.height)
-
-                if spend_selected_coin:
-                    assert selected_coin is not None
-                    await coin_store._set_spent([selected_coin.name], block.height)
+            if not block.is_transaction_block():
+                continue
+            assert block.foliage_transaction_block is not None
+            reward_coins = block.get_included_reward_coins()
+            all_coins += reward_coins
+            await coin_store.new_block(block.height, block.foliage_transaction_block.timestamp, reward_coins, [], [])
+            records = [await coin_store.get_coin_record(coin.name()) for coin in reward_coins]
+
+            spend_selected_coin = selected_coin is not None
+            if block.height != 0 and selected_coin is None:
+                # Select the first CoinRecord which will be spent at the next transaction block.
+                selected_coin = records[0]
+                await coin_store._set_spent([r.name for r in records[1:] if r is not None], block.height)
+            else:
+                await coin_store._set_spent([r.name for r in records if r is not None], block.height)
 
-                records = [await coin_store.get_coin_record(coin.name()) for coin in coins]  # update coin records
-                for record in records:
-                    assert record is not None
-                    if (
-                        selected_coin is not None
-                        and selected_coin.name == record.name
-                        and not selected_coin.confirmed_block_index < block.height
-                    ):
-                        assert not record.spent
-                    else:
-                        assert record.spent
-                        assert record.spent_block_index == block.height
+            if spend_selected_coin:
+                assert selected_coin is not None
+                await coin_store._set_spent([selected_coin.name], block.height)
+
+            records = [await coin_store.get_coin_record(coin.name()) for coin in reward_coins]  # update coin records
+            for record in records:
+                assert record is not None
+                if (
+                    selected_coin is not None
+                    and selected_coin.name == record.name
+                    and not selected_coin.confirmed_block_index < block.height
+                ):
+                    assert not record.spent
+                else:
+                    assert record.spent
+                    assert record.spent_block_index == block.height
 
-                if spend_selected_coin:
-                    break
+            if spend_selected_coin:
+                break
 
         assert selected_coin is not None
         reorg_index = selected_coin.confirmed_block_index
@@ -311,28 +284,29 @@ async def test_rollback(db_version: int, bt: BlockTools) -> None:
 
         # The reorg will revert the creation and spend of many coins. It will also revert the spend (but not the
         # creation) of the selected coin.
-        changed_records = await coin_store.rollback_to_block(reorg_index)
-        changed_coin_records = [cr.coin for cr in changed_records]
-        assert selected_coin in changed_records
+        coin_changes = await coin_store.rollback_to_block(reorg_index)
+        changed_coins = {cr.coin for cr in coin_changes.values()}
+        assert selected_coin.coin in changed_coins
         for coin_record in all_records:
             assert coin_record is not None
             if coin_record.confirmed_block_index > reorg_index:
-                assert coin_record.coin in changed_coin_records
+                assert coin_record.coin in changed_coins
             if coin_record.spent_block_index > reorg_index:
-                assert coin_record.coin in changed_coin_records
+                assert coin_record.coin in changed_coins
 
         for block in blocks:
-            if block.is_transaction_block():
-                coins = block.get_included_reward_coins()
-                records = [await coin_store.get_coin_record(coin.name()) for coin in coins]
+            if not block.is_transaction_block():
+                continue
+            reward_coins = block.get_included_reward_coins()
+            records = [await coin_store.get_coin_record(coin.name()) for coin in reward_coins]
 
-                if block.height <= reorg_index:
-                    for record in records:
-                        assert record is not None
-                        assert record.spent == (record.name != selected_coin.name)
-                else:
-                    for record in records:
-                        assert record is None
+            if block.height <= reorg_index:
+                for record in records:
+                    assert record is not None
+                    assert record.spent == (record.name != selected_coin.name)
+            else:
+                for record in records:
+                    assert record is None
 
 
 @pytest.mark.anyio
@@ -343,7 +317,8 @@ async def test_basic_reorg(tmp_dir: Path, db_version: int, bt: BlockTools) -> No
         blocks = bt.get_consecutive_blocks(initial_block_count)
         coin_store = await CoinStore.create(db_wrapper)
         store = await BlockStore.create(db_wrapper)
-        b: Blockchain = await Blockchain.create(coin_store, store, bt.constants, tmp_dir, 2)
+        height_map = await BlockHeightMap.create(tmp_dir, db_wrapper)
+        b: Blockchain = await Blockchain.create(coin_store, store, height_map, bt.constants, 2)
         try:
             records: list[Optional[CoinRecord]] = []
 
@@ -409,7 +384,8 @@ async def test_get_puzzle_hash(tmp_dir: Path, db_version: int, bt: BlockTools) -
         )
         coin_store = await CoinStore.create(db_wrapper)
         store = await BlockStore.create(db_wrapper)
-        b: Blockchain = await Blockchain.create(coin_store, store, bt.constants, tmp_dir, 2)
+        height_map = await BlockHeightMap.create(tmp_dir, db_wrapper)
+        b: Blockchain = await Blockchain.create(coin_store, store, height_map, bt.constants, 2)
         for block in blocks:
             await _validate_and_add_block(b, block)
         peak = b.get_peak()
@@ -449,7 +425,7 @@ async def test_get_coin_states(db_version: int) -> None:
             for i in range(1, 301)
         ]
         coin_store = await CoinStore.create(db_wrapper)
-        await coin_store._add_coin_records(crs)
+        await add_coin_records_to_db(coin_store, crs)
 
         assert len(await coin_store.get_coin_states_by_puzzle_hashes(True, {std_hash(b"2")}, uint32(0))) == 300
         assert len(await coin_store.get_coin_states_by_puzzle_hashes(False, {std_hash(b"2")}, uint32(0))) == 0
@@ -577,7 +553,7 @@ async def test_coin_state_batches(
         coin_store = await CoinStore.create(db_wrapper)
         hint_store = await HintStore.create(db_wrapper)
 
-        await coin_store._add_coin_records(random_coin_records.items)
+        await add_coin_records_to_db(coin_store, random_coin_records.items)
         await hint_store.add_hints(random_coin_records.hints)
 
         # Make sure all of the coin states are found when batching.
@@ -671,7 +647,7 @@ async def test_batch_many_coin_states(db_version: int, cut_off_middle: bool) ->
         coin_store = await CoinStore.create(db_wrapper)
         await HintStore.create(db_wrapper)
 
-        await coin_store._add_coin_records(coin_records)
+        await add_coin_records_to_db(coin_store, coin_records)
 
         # Make sure all of the coin states are found.
         (all_coin_states, next_height) = await coin_store.batch_coin_states_by_puzzle_hashes([ph])
@@ -684,7 +660,8 @@ async def test_batch_many_coin_states(db_version: int, cut_off_middle: bool) ->
             assert coin_records[i].coin.name().hex() == all_coin_states[i].coin.name().hex(), i
 
         # For the middle case, insert a coin record between the two heights 10 and 12.
-        await coin_store._add_coin_records(
+        await add_coin_records_to_db(
+            coin_store,
             [
                 CoinRecord(
                     coin=Coin(std_hash(b"extra coin"), ph, uint64(0)),
@@ -695,7 +672,7 @@ async def test_batch_many_coin_states(db_version: int, cut_off_middle: bool) ->
                     coinbase=False,
                     timestamp=uint64(0),
                 )
-            ]
+            ],
         )
 
         (all_coin_states, next_height) = await coin_store.batch_coin_states_by_puzzle_hashes([ph])
@@ -732,7 +709,7 @@ async def test_duplicate_by_hint(db_version: int) -> None:
             uint64(12321312),
         )
 
-        await coin_store._add_coin_records([cr])
+        await add_coin_records_to_db(coin_store, [cr])
         await hint_store.add_hints([(cr.coin.name(), cr.coin.puzzle_hash)])
 
         coin_states, height = await coin_store.batch_coin_states_by_puzzle_hashes([cr.coin.puzzle_hash])
@@ -763,7 +740,7 @@ class UnspentLineageInfoTestItem:
     puzzlehash: bytes
     amount: int
     parent_id: bytes
-    is_spent: bool = False
+    spent_index: int = 0
 
 
 @dataclass
@@ -783,7 +760,7 @@ class UnspentLineageInfoCase:
             UnspentLineageInfoTestItem(TEST_COIN_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_ID),
             UnspentLineageInfoTestItem(b"2" * 32, b"2" * 32, 2, b"1" * 32),
             UnspentLineageInfoTestItem(b"3" * 32, b"3" * 32, 3, b"2" * 32),
-            UnspentLineageInfoTestItem(TEST_PARENT_ID, b"4" * 32, TEST_AMOUNT, TEST_PARENT_PARENT_ID, is_spent=True),
+            UnspentLineageInfoTestItem(TEST_PARENT_ID, b"4" * 32, TEST_AMOUNT, TEST_PARENT_PARENT_ID, spent_index=1),
         ],
         expected_success=False,
     ),
@@ -798,11 +775,11 @@ class UnspentLineageInfoCase:
                 TEST_PUZZLEHASH,
                 TEST_PARENT_DIFFERENT_AMOUNT,
                 TEST_PARENT_PARENT_ID,
-                is_spent=True,
+                spent_index=1,
             ),
         ],
         parent_with_diff_amount=True,
-        expected_success=True,
+        expected_success=False,
     ),
     UnspentLineageInfoCase(
         id="Unspent with parent that has same puzzlehash and amount but is also unspent",
@@ -821,7 +798,7 @@ class UnspentLineageInfoCase:
             UnspentLineageInfoTestItem(b"2" * 32, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_ID),
             UnspentLineageInfoTestItem(b"3" * 32, b"3" * 32, 3, b"2" * 32),
             UnspentLineageInfoTestItem(
-                TEST_PARENT_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_PARENT_ID, is_spent=True
+                TEST_PARENT_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_PARENT_ID, spent_index=1
             ),
         ],
         expected_success=False,
@@ -829,11 +806,11 @@ class UnspentLineageInfoCase:
     UnspentLineageInfoCase(
         id="Unspent with parent that has same puzzlehash and amount",
         items=[
-            UnspentLineageInfoTestItem(TEST_COIN_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_ID),
+            UnspentLineageInfoTestItem(TEST_COIN_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_ID, spent_index=-1),
             UnspentLineageInfoTestItem(b"2" * 32, b"2" * 32, 2, b"1" * 32),
             UnspentLineageInfoTestItem(b"3" * 32, b"3" * 32, 3, b"2" * 32),
             UnspentLineageInfoTestItem(
-                TEST_PARENT_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_PARENT_ID, is_spent=True
+                TEST_PARENT_ID, TEST_PUZZLEHASH, TEST_AMOUNT, TEST_PARENT_PARENT_ID, spent_index=1
             ),
         ],
         expected_success=True,
@@ -858,7 +835,7 @@ async def test_get_unspent_lineage_info_for_puzzle_hash(case: UnspentLineageInfo
                 (
                     item.coin_id,
                     0,
-                    1 if item.is_spent else 0,
+                    item.spent_index,
                     0,
                     item.puzzlehash,
                     item.parent_id,
@@ -884,14 +861,129 @@ async def test_get_unspent_lineage_info_for_puzzle_hash(case: UnspentLineageInfo
         if case.expected_success:
             assert result == UnspentLineageInfo(
                 coin_id=bytes32(TEST_COIN_ID),
-                coin_amount=TEST_AMOUNT,
                 parent_id=(
                     bytes32(TEST_PARENT_ID_DIFFERENT_AMOUNT)
                     if case.parent_with_diff_amount
                     else bytes32(TEST_PARENT_ID)
                 ),
-                parent_amount=TEST_PARENT_DIFFERENT_AMOUNT if case.parent_with_diff_amount else TEST_AMOUNT,
                 parent_parent_id=bytes32(TEST_PARENT_PARENT_ID),
             )
         else:
             assert result is None
+
+
+@pytest.mark.anyio
+async def test_add_coin_records_to_db() -> None:
+    async with DBConnection(2) as db_wrapper:
+        coin_store = await CoinStore.create(db_wrapper)
+        test_records = [
+            CoinRecord(
+                coin=Coin(bytes32([i * 2] * 32), bytes32([i * 2 + 1] * 32), uint64(i)),
+                confirmed_block_index=uint32(i + 1),
+                spent_block_index=uint32(i),
+                coinbase=i % 2 == 0,
+                timestamp=uint64(i),
+            )
+            for i in range(5)
+        ]
+        await add_coin_records_to_db(coin_store, test_records)
+        # Verify all records got inserted correctly
+        for record in test_records:
+            resulting_record = await coin_store.get_coin_record(record.coin.name())
+            assert resulting_record is not None
+            assert resulting_record == record
+
+
+async def get_spent_index(conn: aiosqlite.Connection, coin_name: bytes32) -> int:
+    cursor = await conn.execute("SELECT spent_index FROM coin_record WHERE coin_name = ?", (coin_name,))
+    row = await cursor.fetchone()
+    assert row is not None
+    return int(row[0])
+
+
+@pytest.mark.anyio
+async def test_new_block_tx_additions() -> None:
+    """
+    Covers properly adding coin records for normal unspent coins and potential
+    fast forward singleton unspent coins. That means giving them spent index 0
+    and -1 respectively.
+    """
+    async with DBConnection(2) as db_wrapper:
+        coin_store = await CoinStore.create(db_wrapper)
+        normal_coin = Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(1))
+        normal_coin_id = normal_coin.name()
+        same_as_parent_coin = Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(1337))
+        same_as_parent_coin_id = same_as_parent_coin.name()
+        await coin_store.new_block(
+            height=uint32(0),
+            timestamp=uint64(1),
+            included_reward_coins=[],
+            tx_additions=[
+                (normal_coin_id, normal_coin, False),
+                (same_as_parent_coin_id, same_as_parent_coin, True),
+            ],
+            tx_removals=[],
+        )
+        async with db_wrapper.reader_no_transaction() as conn:
+            # Normal coin should have spent_index 0
+            assert await get_spent_index(conn, normal_coin_id) == 0
+            # Potential ff singleton should have spent_index -1
+            assert await get_spent_index(conn, same_as_parent_coin_id) == -1
+
+
+@pytest.mark.anyio
+async def test_rollback_to_block_spent_index_update() -> None:
+    """
+    Covers properly marking coins as unspent on rollback. Reward coins and
+    normal coins get `spent_index` set to `0`, potential ff singleton ones get
+    `spent_index` set to `-1`.
+    """
+
+    async def insert_coins(db_wrapper: DBWrapper2, coins: list[tuple[Coin, int, bool]]) -> None:
+        values_to_insert = [
+            (
+                coin.name(),
+                0,
+                spent_index,
+                int(coinbase),
+                coin.puzzle_hash,
+                coin.parent_coin_info,
+                coin.amount.stream_to_bytes(),
+                0,
+            )
+            for coin, spent_index, coinbase in coins
+        ]
+        async with db_wrapper.writer() as conn:
+            await conn.executemany("INSERT INTO coin_record VALUES (?, ?, ?, ?, ?, ?, ?, ?)", values_to_insert)
+
+    async with DBConnection(2) as db_wrapper:
+        coin_store = await CoinStore.create(db_wrapper)
+        # Let's set things up for roll back. All coins are confirmed at height
+        # 0, parent coin gets spent at height 2 and the other test coins get
+        # spent at height 3.
+        parent_coin = Coin(bytes32([0] * 32), bytes32([1] * 32), uint64(1337))
+        parent_coin_id = parent_coin.name()
+        normal_child = Coin(parent_coin_id, bytes32([2] * 32), uint64(42))
+        same_as_parent_child = Coin(parent_coin_id, parent_coin.puzzle_hash, parent_coin.amount)
+        reward_coin = Coin(bytes32([0] * 32), bytes32([0] * 32), uint64(1))
+        await insert_coins(
+            db_wrapper,
+            # List of (coin, spent_index, coinbase) values
+            [
+                (parent_coin, 2, False),
+                (normal_child, 3, False),
+                (same_as_parent_child, 3, False),
+                (reward_coin, 3, True),
+            ],
+        )
+        # Let's roll back
+        await coin_store.rollback_to_block(2)
+        async with db_wrapper.reader_no_transaction() as conn:
+            # Parent should still be spent
+            assert await get_spent_index(conn, parent_coin_id) == 2
+            # Normal child should be unspent with spent_index 0
+            assert await get_spent_index(conn, normal_child.name()) == 0
+            # Same for the reward coin
+            assert await get_spent_index(conn, reward_coin.name()) == 0
+            # The potential ff singleton child should be marked with -1
+            assert await get_spent_index(conn, same_as_parent_child.name()) == -1