chia-blockchain 2.4.4__py3-none-any.whl

chia/wallet/wallet_puzzle_store.py

@@ -0,0 +1,365 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Dict, List, Optional, Set
+
+from chia_rs import G1Element
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.db_wrapper import DBWrapper2, execute_fetchone
+from chia.util.ints import uint32
+from chia.util.lru_cache import LRUCache
+from chia.wallet.derivation_record import DerivationRecord
+from chia.wallet.util.wallet_types import WalletIdentifier, WalletType
+
+log = logging.getLogger(__name__)
+
+
+class WalletPuzzleStore:
+    """
+    WalletPuzzleStore keeps track of all generated puzzle_hashes and their derivation path / wallet.
+    This is only used for HD wallets where each address is derived from a public key. Otherwise, use the
+    WalletInterestedStore to keep track of puzzle hashes which we are interested in.
+    """
+
+    lock: asyncio.Lock
+    db_wrapper: DBWrapper2
+    wallet_identifier_cache: LRUCache
+    # maps wallet_id -> last_derivation_index
+    last_wallet_derivation_index: Dict[uint32, uint32]
+    last_derivation_index: Optional[uint32]
+
+    @classmethod
+    async def create(cls, db_wrapper: DBWrapper2):
+        self = cls()
+        self.db_wrapper = db_wrapper
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            await conn.execute(
+                "CREATE TABLE IF NOT EXISTS derivation_paths("
+                "derivation_index int,"
+                " pubkey text,"
+                " puzzle_hash text,"
+                " wallet_type int,"
+                " wallet_id int,"
+                " used tinyint,"
+                " hardened tinyint,"
+                " PRIMARY KEY(puzzle_hash, wallet_id))"
+            )
+            await conn.execute(
+                "CREATE INDEX IF NOT EXISTS derivation_index_index on derivation_paths(derivation_index)"
+            )
+            await conn.execute("CREATE INDEX IF NOT EXISTS pubkey on derivation_paths(pubkey)")
+            await conn.execute("CREATE INDEX IF NOT EXISTS ph on derivation_paths(puzzle_hash)")
+            await conn.execute("CREATE INDEX IF NOT EXISTS wallet_type on derivation_paths(wallet_type)")
+            # Remove an old, misnamed, redundant index on `wallet_type`
+            # See https://github.com/Chia-Network/chia-blockchain/issues/10276
+            await conn.execute("DROP INDEX IF EXISTS used")
+            await conn.execute("CREATE INDEX IF NOT EXISTS derivation_paths_wallet_id on derivation_paths(wallet_id)")
+            await conn.execute("CREATE INDEX IF NOT EXISTS derivation_paths_used_index on derivation_paths(used)")
+            await conn.execute(
+                "CREATE INDEX IF NOT EXISTS derivation_paths_hardened_index on derivation_paths(hardened)"
+            )
+
+        # the lock is locked by the users of this class
+        self.lock = asyncio.Lock()
+        self.wallet_identifier_cache = LRUCache(100)
+        self.last_derivation_index = None
+        self.last_wallet_derivation_index = {}
+        return self
+
+    async def add_derivation_paths(self, records: List[DerivationRecord]) -> None:
+        """
+        Insert many derivation paths into the database.
+        """
+        if len(records) == 0:
+            return
+        sql_records = []
+        for record in records:
+            log.debug("Adding derivation record: %s", record)
+            if record.hardened:
+                hardened = 1
+            else:
+                hardened = 0
+            sql_records.append(
+                (
+                    record.index,
+                    bytes(record.pubkey).hex(),
+                    record.puzzle_hash.hex(),
+                    record.wallet_type,
+                    record.wallet_id,
+                    0,
+                    hardened,
+                ),
+            )
+            self.last_derivation_index = (
+                record.index if self.last_derivation_index is None else max(self.last_derivation_index, record.index)
+            )
+            if record.wallet_id not in self.last_wallet_derivation_index:
+                self.last_wallet_derivation_index[record.wallet_id] = record.index
+            else:
+                self.last_wallet_derivation_index[record.wallet_id] = max(
+                    self.last_wallet_derivation_index[record.wallet_id], record.index
+                )
+
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            await (
+                await conn.executemany(
+                    "INSERT OR REPLACE INTO derivation_paths VALUES(?, ?, ?, ?, ?, ?, ?)",
+                    sql_records,
+                )
+            ).close()
+
+    async def get_derivation_record(
+        self, index: uint32, wallet_id: uint32, hardened: bool
+    ) -> Optional[DerivationRecord]:
+        """
+        Returns the derivation record by index and wallet id.
+        """
+        if hardened:
+            hard = 1
+        else:
+            hard = 0
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(
+                conn,
+                "SELECT derivation_index, pubkey, puzzle_hash, wallet_type, wallet_id, used FROM derivation_paths "
+                "WHERE derivation_index=? AND wallet_id=? AND hardened=?",
+                (index, wallet_id, hard),
+            )
+
+        if row is not None and row[0] is not None:
+            return self.row_to_record(row)
+
+        return None
+
+    async def get_derivation_record_for_puzzle_hash(self, puzzle_hash: bytes32) -> Optional[DerivationRecord]:
+        """
+        Returns the derivation record by index and wallet id.
+        """
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(
+                conn,
+                "SELECT derivation_index, pubkey, puzzle_hash, wallet_type, wallet_id, hardened FROM derivation_paths "
+                "WHERE puzzle_hash=?",
+                (puzzle_hash.hex(),),
+            )
+
+        if row is not None and row[0] is not None:
+            return self.row_to_record(row)
+
+        return None
+
+    async def set_used_up_to(self, index: uint32) -> None:
+        """
+        Sets a derivation path to used so we don't use it again.
+        """
+
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            await conn.execute_insert(
+                "UPDATE derivation_paths SET used=1 WHERE derivation_index<=?",
+                (index,),
+            )
+
+    async def puzzle_hash_exists(self, puzzle_hash: bytes32) -> bool:
+        """
+        Checks if passed puzzle_hash is present in the db.
+        """
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(
+                conn, "SELECT puzzle_hash FROM derivation_paths WHERE puzzle_hash=?", (puzzle_hash.hex(),)
+            )
+
+        return row is not None
+
+    def row_to_record(self, row) -> DerivationRecord:
+        return DerivationRecord(
+            uint32(row[0]),
+            bytes32.fromhex(row[2]),
+            G1Element.from_bytes(bytes.fromhex(row[1])),
+            WalletType(row[3]),
+            uint32(row[4]),
+            bool(row[5]),
+        )
+
+    async def index_for_pubkey(self, pubkey: G1Element) -> Optional[uint32]:
+        """
+        Returns derivation paths for the given pubkey.
+        Returns None if not present.
+        """
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(
+                conn, "SELECT derivation_index FROM derivation_paths WHERE pubkey=?", (bytes(pubkey).hex(),)
+            )
+
+        if row is not None:
+            return uint32(row[0])
+
+        return None
+
+    async def record_for_pubkey(self, pubkey: G1Element) -> Optional[DerivationRecord]:
+        """
+        Returns derivation record for the given pubkey.
+        Returns None if not present.
+        """
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(
+                conn,
+                "SELECT derivation_index, pubkey, puzzle_hash, wallet_type, wallet_id, hardened "
+                "FROM derivation_paths "
+                "WHERE pubkey=?",
+                (bytes(pubkey).hex(),),
+            )
+
+        return None if row is None else self.row_to_record(row)
+
+    async def index_for_puzzle_hash(self, puzzle_hash: bytes32) -> Optional[uint32]:
+        """
+        Returns the derivation path for the puzzle_hash.
+        Returns None if not present.
+        """
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(
+                conn, "SELECT derivation_index FROM derivation_paths WHERE puzzle_hash=?", (puzzle_hash.hex(),)
+            )
+        return None if row is None else uint32(row[0])
+
+    async def record_for_puzzle_hash(self, puzzle_hash: bytes32) -> Optional[DerivationRecord]:
+        """
+        Returns the derivation path for the puzzle_hash.
+        Returns None if not present.
+        """
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(
+                conn,
+                "SELECT derivation_index, pubkey, puzzle_hash, wallet_type, wallet_id, hardened "
+                "FROM derivation_paths "
+                "WHERE puzzle_hash=?",
+                (puzzle_hash.hex(),),
+            )
+
+        if row is not None and row[0] is not None:
+            return self.row_to_record(row)
+
+        return None
+
+    async def get_wallet_identifier_for_puzzle_hash(self, puzzle_hash: bytes32) -> Optional[WalletIdentifier]:
+        """
+        Returns the derivation path for the puzzle_hash.
+        Returns None if not present.
+        """
+        cached = self.wallet_identifier_cache.get(puzzle_hash)
+        if cached is not None:
+            return cached
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(
+                conn, "SELECT wallet_type, wallet_id FROM derivation_paths WHERE puzzle_hash=?", (puzzle_hash.hex(),)
+            )
+
+        if row is not None:
+            wallet_identifier = WalletIdentifier(uint32(row[1]), WalletType(row[0]))
+            self.wallet_identifier_cache.put(puzzle_hash, wallet_identifier)
+            return wallet_identifier
+
+        return None
+
+    async def get_all_puzzle_hashes(self, wallet_id: Optional[int] = None) -> Set[bytes32]:
+        """
+        Return a set containing all puzzle_hashes we generated.
+        """
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            if wallet_id is None:
+                rows = await conn.execute_fetchall("SELECT puzzle_hash FROM derivation_paths")
+            else:
+                rows = await conn.execute_fetchall(
+                    "SELECT puzzle_hash FROM derivation_paths WHERE wallet_id=?", (wallet_id,)
+                )
+            return {bytes32.fromhex(row[0]) for row in rows}
+
+    async def get_last_derivation_path(self) -> Optional[uint32]:
+        """
+        Returns the last derivation path by derivation_index.
+        """
+        if self.last_derivation_index is not None:
+            return self.last_derivation_index
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(conn, "SELECT MAX(derivation_index) FROM derivation_paths")
+            last_derivation_index = None if row is None or row[0] is None else uint32(row[0])
+            self.last_derivation_index = last_derivation_index
+            return self.last_derivation_index
+
+    async def get_last_derivation_path_for_wallet(self, wallet_id: int) -> Optional[uint32]:
+        """
+        Returns the last derivation path by derivation_index.
+        """
+        cached_derivation_index: Optional[uint32] = self.last_wallet_derivation_index.get(uint32(wallet_id))
+        if cached_derivation_index is not None:
+            return cached_derivation_index
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(
+                conn, "SELECT MAX(derivation_index) FROM derivation_paths WHERE wallet_id=?", (wallet_id,)
+            )
+            derivation_index = None if row is None or row[0] is None else uint32(row[0])
+            if derivation_index is not None:
+                self.last_wallet_derivation_index[uint32(wallet_id)] = derivation_index
+            return derivation_index
+
+    async def get_current_derivation_record_for_wallet(self, wallet_id: uint32) -> Optional[DerivationRecord]:
+        """
+        Returns the current derivation record by derivation_index.
+        """
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(
+                conn,
+                "SELECT MAX(derivation_index) FROM derivation_paths WHERE wallet_id=? AND used=1 AND hardened=0",
+                (wallet_id,),
+            )
+
+        if row is not None and row[0] is not None:
+            index = uint32(row[0])
+            return await self.get_derivation_record(index, wallet_id, False)
+
+        return None
+
+    async def get_unused_derivation_path(self) -> Optional[uint32]:
+        """
+        Returns the first unused derivation path by derivation_index.
+        """
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            row = await execute_fetchone(
+                conn, "SELECT MIN(derivation_index) FROM derivation_paths WHERE used=0 AND hardened=0;"
+            )
+
+        if row is not None and row[0] is not None:
+            return uint32(row[0])
+
+        return None
+
+    async def delete_wallet(self, wallet_id: uint32) -> None:
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            # First fetch all puzzle hashes since we need them to drop them from the cache
+            rows = await conn.execute_fetchall(
+                "SELECT puzzle_hash FROM derivation_paths WHERE wallet_id=?", (wallet_id,)
+            )
+            cursor = await conn.execute("DELETE FROM derivation_paths WHERE wallet_id=?;", (wallet_id,))
+            await cursor.close()
+        # Clear caches
+        puzzle_hashes = {bytes32.fromhex(row[0]) for row in rows}
+        for puzzle_hash in puzzle_hashes:
+            try:
+                self.wallet_identifier_cache.remove(puzzle_hash)
+            except KeyError:
+                pass
+        try:
+            self.last_wallet_derivation_index.pop(wallet_id)
+        except KeyError:
+            pass
+        self.last_derivation_index = None

chia/wallet/wallet_retry_store.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from typing import List, Optional, Tuple
+
+from chia_rs import CoinState
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.db_wrapper import DBWrapper2
+from chia.util.ints import uint32
+
+
+class WalletRetryStore:
+    """
+    Persistent coin states that we have received but failed to add
+    """
+
+    db_wrapper: DBWrapper2
+
+    @classmethod
+    async def create(cls, db_wrapper: DBWrapper2) -> WalletRetryStore:
+        self = cls()
+        self.db_wrapper = db_wrapper
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            await conn.execute(
+                "CREATE TABLE IF NOT EXISTS retry_store("
+                " coin_state blob PRIMARY KEY,"
+                " peer blob,"
+                " fork_height int)"
+            )
+
+        return self
+
+    async def get_all_states_to_retry(self) -> List[Tuple[CoinState, bytes32, uint32]]:
+        """
+        Return all states that were failed to sync
+        """
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            rows = await conn.execute_fetchall("SELECT * from retry_store")
+
+        return [(CoinState.from_bytes(row[0]), bytes32(row[1]), uint32(row[2])) for row in rows]
+
+    async def add_state(self, state: CoinState, peer_id: bytes32, fork_height: Optional[uint32]) -> None:
+        """
+        Adds object to key val store. Obj MUST support __bytes__ and bytes() methods.
+        """
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            cursor = await conn.execute(
+                "INSERT OR IGNORE INTO retry_store VALUES(?, ?, ?)",
+                (bytes(state), peer_id, 0 if fork_height is None else fork_height),
+            )
+            await cursor.close()
+
+    async def remove_state(self, state: CoinState) -> None:
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            cursor = await conn.execute("DELETE FROM retry_store where coin_state=?", (bytes(state),))
+            await cursor.close()
+
+    async def rollback_to_block(self, height: int) -> None:
+        """
+        Delete all ignored states above a certain height
+        :param height: Reorg height
+        :return None:
+        """
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            cursor = await conn.execute(
+                "DELETE from retry_store WHERE fork_height>?",
+                (height,),
+            )
+            await cursor.close()

chia/wallet/wallet_singleton_store.py

@@ -0,0 +1,258 @@
+from __future__ import annotations
+
+import json
+import logging
+from sqlite3 import Row
+from typing import List, Optional, Type, TypeVar, Union
+
+from clvm.casts import int_from_bytes
+
+from chia.consensus.default_constants import DEFAULT_CONSTANTS
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.types.coin_spend import CoinSpend
+from chia.types.condition_opcodes import ConditionOpcode
+from chia.util.condition_tools import conditions_dict_for_solution
+from chia.util.db_wrapper import DBWrapper2, execute_fetchone
+from chia.util.ints import uint32, uint64
+from chia.wallet import singleton
+from chia.wallet.lineage_proof import LineageProof
+from chia.wallet.singleton import get_inner_puzzle_from_singleton, get_singleton_id_from_puzzle
+from chia.wallet.singleton_record import SingletonRecord
+
+log = logging.getLogger(__name__)
+_T_WalletSingletonStore = TypeVar("_T_WalletSingletonStore", bound="WalletSingletonStore")
+
+
+class WalletSingletonStore:
+    db_wrapper: DBWrapper2
+
+    @classmethod
+    async def create(cls: Type[_T_WalletSingletonStore], wrapper: DBWrapper2) -> _T_WalletSingletonStore:
+        self = cls()
+        self.db_wrapper = wrapper
+
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            await conn.execute(
+                "CREATE TABLE IF NOT EXISTS singletons("
+                "coin_id blob PRIMARY KEY,"
+                " coin text,"
+                " singleton_id blob,"
+                " wallet_id int,"
+                " parent_coin_spend blob,"
+                " inner_puzzle_hash blob,"
+                " pending tinyint,"
+                " removed_height int,"
+                " lineage_proof blob,"
+                " custom_data blob)"
+            )
+
+            await conn.execute("CREATE INDEX IF NOT EXISTS removed_height_index on singletons(removed_height)")
+
+        return self
+
+    async def save_singleton(self, record: SingletonRecord) -> None:
+        singleton_id = singleton.get_singleton_id_from_puzzle(record.parent_coinspend.puzzle_reveal)
+        if singleton_id is None:  # pragma: no cover
+            raise RuntimeError(
+                "Failed to derive Singleton ID from puzzle reveal in parent spend %s", record.parent_coinspend
+            )
+        pending_int = 0
+        if record.pending:
+            pending_int = 1
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            columns = (
+                "coin_id, coin, singleton_id, wallet_id, parent_coin_spend, inner_puzzle_hash, "
+                "pending, removed_height, lineage_proof, custom_data"
+            )
+            await conn.execute(
+                f"INSERT or REPLACE INTO singletons ({columns}) VALUES(?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                (
+                    record.coin.name().hex(),
+                    json.dumps(record.coin.to_json_dict()),
+                    singleton_id.hex(),
+                    record.wallet_id,
+                    bytes(record.parent_coinspend),
+                    record.inner_puzzle_hash,
+                    pending_int,
+                    record.removed_height,
+                    bytes(record.lineage_proof),
+                    record.custom_data,
+                ),
+            )
+
+    async def add_spend(
+        self,
+        wallet_id: uint32,
+        coin_state: CoinSpend,
+        block_height: uint32 = uint32(0),
+        pending: bool = True,
+    ) -> None:
+        """Given a coin spend of a singleton, attempt to calculate the child coin and details
+        for the new singleton record. Add the new record to the store and remove the old record
+        if it exists
+        """
+        # get singleton_id from puzzle_reveal
+        singleton_id = get_singleton_id_from_puzzle(coin_state.puzzle_reveal)
+        if not singleton_id:
+            raise RuntimeError("Coin to add is not a valid singleton")
+
+        # get details for singleton record
+        conditions = conditions_dict_for_solution(
+            coin_state.puzzle_reveal, coin_state.solution, DEFAULT_CONSTANTS.MAX_BLOCK_COST_CLVM
+        )
+
+        cc_cond = [cond for cond in conditions[ConditionOpcode.CREATE_COIN] if int_from_bytes(cond.vars[1]) % 2 == 1][0]
+
+        coin = Coin(coin_state.coin.name(), cc_cond.vars[0], uint64(int_from_bytes(cc_cond.vars[1])))
+        inner_puz = get_inner_puzzle_from_singleton(coin_state.puzzle_reveal)
+        if inner_puz is None:  # pragma: no cover
+            raise RuntimeError("Could not get inner puzzle from puzzle reveal in coin spend %s", coin_state)
+
+        lineage_bytes = [x.as_atom() for x in coin_state.solution.to_program().first().as_iter()]
+        if len(lineage_bytes) == 2:
+            lineage_proof = LineageProof(bytes32(lineage_bytes[0]), None, uint64(int_from_bytes(lineage_bytes[1])))
+        else:
+            lineage_proof = LineageProof(
+                bytes32(lineage_bytes[0]), bytes32(lineage_bytes[1]), uint64(int_from_bytes(lineage_bytes[2]))
+            )
+        # Create and save the new singleton record
+        new_record = SingletonRecord(
+            coin, singleton_id, wallet_id, coin_state, inner_puz.get_tree_hash(), pending, 0, lineage_proof, None
+        )
+        await self.save_singleton(new_record)
+        # check if coin is in DB and mark deleted if found
+        current_records = await self.get_records_by_coin_id(coin_state.coin.name())
+        if len(current_records) > 0:
+            await self.delete_singleton_by_coin_id(coin_state.coin.name(), block_height)
+        return
+
+    def _to_singleton_record(self, row: Row) -> SingletonRecord:
+        return SingletonRecord(
+            coin=Coin.from_json_dict(json.loads(row[1])),
+            singleton_id=bytes32.from_hexstr(row[2]),
+            wallet_id=uint32(row[3]),
+            parent_coinspend=CoinSpend.from_bytes(row[4]),
+            inner_puzzle_hash=bytes32.from_bytes(row[5]),  # inner puz hash
+            pending=True if row[6] == 1 else False,
+            removed_height=uint32(row[7]),
+            lineage_proof=LineageProof.from_bytes(row[8]),
+            custom_data=row[9],
+        )
+
+    async def delete_singleton_by_singleton_id(self, singleton_id: bytes32, height: uint32) -> bool:
+        """Tries to mark a given singleton as deleted at specific height
+
+        This is due to how re-org works
+        Returns `True` if singleton was found and marked deleted or `False` if not."""
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            cursor = await conn.execute(
+                "UPDATE singletons SET removed_height=? WHERE singleton_id=?", (int(height), singleton_id.hex())
+            )
+            if cursor.rowcount > 0:
+                log.info("Deleted singleton with singleton id: %s", singleton_id.hex())
+                return True
+            log.warning("Couldn't find singleton with singleton id to delete: %s", singleton_id.hex())
+            return False
+
+    async def delete_singleton_by_coin_id(self, coin_id: bytes32, height: uint32) -> bool:
+        """Tries to mark a given singleton as deleted at specific height
+
+        This is due to how re-org works
+        Returns `True` if singleton was found and marked deleted or `False` if not."""
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            cursor = await conn.execute(
+                "UPDATE singletons SET removed_height=? WHERE coin_id=?", (int(height), coin_id.hex())
+            )
+            if cursor.rowcount > 0:
+                log.info("Deleted singleton with coin id: %s", coin_id.hex())
+                return True
+            log.warning("Couldn't find singleton with coin id to delete: %s", coin_id.hex())
+            return False
+
+    async def delete_wallet(self, wallet_id: uint32) -> None:
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            cursor = await conn.execute("DELETE FROM singletons WHERE wallet_id=?", (wallet_id,))
+            await cursor.close()
+
+    async def update_pending_transaction(self, coin_id: bytes32, pending: bool) -> bool:
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            c = await conn.execute(
+                "UPDATE singletons SET pending=? WHERE coin_id = ?",
+                (pending, coin_id.hex()),
+            )
+            return c.rowcount > 0
+
+    async def get_records_by_wallet_id(self, wallet_id: int) -> List[SingletonRecord]:
+        """
+        Retrieves all entries for a wallet ID.
+        """
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            rows = await conn.execute_fetchall(
+                "SELECT * FROM singletons WHERE wallet_id = ? ORDER BY removed_height",
+                (wallet_id,),
+            )
+        return [self._to_singleton_record(row) for row in rows]
+
+    async def get_records_by_coin_id(self, coin_id: bytes32) -> List[SingletonRecord]:
+        """
+        Retrieves all entries for a coin ID.
+        """
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            rows = await conn.execute_fetchall(
+                "SELECT * FROM singletons WHERE coin_id = ?",
+                (coin_id.hex(),),
+            )
+        return [self._to_singleton_record(row) for row in rows]
+
+    async def get_records_by_singleton_id(self, singleton_id: bytes32) -> List[SingletonRecord]:
+        """
+        Retrieves all entries for a singleton ID.
+        """
+
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            rows = await conn.execute_fetchall(
+                "SELECT * FROM singletons WHERE singleton_id = ? ORDER BY removed_height",
+                (singleton_id.hex(),),
+            )
+        return [self._to_singleton_record(row) for row in rows]
+
+    async def rollback(self, height: int, wallet_id_arg: int) -> None:
+        """
+        Rollback removes all entries which have entry_height > height passed in. Note that this is not committed to the
+        DB until db_wrapper.commit() is called. However, it is written to the cache, so it can be fetched with
+        get_all_state_transitions.
+        """
+
+        async with self.db_wrapper.writer_maybe_transaction() as conn:
+            cursor = await conn.execute(
+                "DELETE FROM singletons WHERE removed_height>? AND wallet_id=?", (height, wallet_id_arg)
+            )
+            await cursor.close()
+
+    async def count(self, wallet_id: Optional[uint32] = None) -> int:
+        sql = "SELECT COUNT(singleton_id) FROM singletons WHERE removed_height=0"
+        params: List[uint32] = []
+        if wallet_id is not None:
+            sql += " AND wallet_id=?"
+            params.append(wallet_id)
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            count_row = await execute_fetchone(conn, sql, params)
+            if count_row:
+                return int(count_row[0])
+        return -1  # pragma: no cover
+
+    async def is_empty(self, wallet_id: Optional[uint32] = None) -> bool:
+        sql = "SELECT 1 FROM singletons WHERE removed_height=0"
+        params: List[Union[uint32, bytes32]] = []
+        if wallet_id is not None:
+            sql += " AND wallet_id=?"
+            params.append(wallet_id)
+        sql += " LIMIT 1"
+        async with self.db_wrapper.reader_no_transaction() as conn:
+            count_row = await execute_fetchone(conn, sql, params)
+            if count_row:
+                return False
+        return True