chia-blockchain 2.4.4__py3-none-any.whl

chia/types/blockchain_format/foliage.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+import chia_rs
+
+TransactionsInfo = chia_rs.TransactionsInfo
+FoliageTransactionBlock = chia_rs.FoliageTransactionBlock
+FoliageBlockData = chia_rs.FoliageBlockData
+Foliage = chia_rs.Foliage

chia/types/blockchain_format/pool_target.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+import chia_rs
+
+PoolTarget = chia_rs.PoolTarget

chia/types/blockchain_format/program.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+
+import io
+from typing import TYPE_CHECKING, Any, Callable, Dict, Optional, Set, Tuple, Type, TypeVar
+
+from chia_rs import ALLOW_BACKREFS, MEMPOOL_MODE, run_chia_program, tree_hash
+from clvm.casts import int_from_bytes
+from clvm.CLVMObject import CLVMStorage
+from clvm.EvalError import EvalError
+from clvm.serialize import sexp_from_stream, sexp_to_stream
+from clvm.SExp import SExp
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.byte_types import hexstr_to_bytes
+from chia.util.hash import std_hash
+
+from .tree_hash import sha256_treehash
+
+INFINITE_COST = 11000000000
+
+DEFAULT_FLAGS = MEMPOOL_MODE
+
+T_CLVMStorage = TypeVar("T_CLVMStorage", bound=CLVMStorage)
+T_Program = TypeVar("T_Program", bound="Program")
+
+
+class Program(SExp):
+    """
+    A thin wrapper around s-expression data intended to be invoked with "eval".
+    """
+
+    @classmethod
+    def parse(cls: Type[T_Program], f) -> T_Program:
+        return sexp_from_stream(f, cls.to)
+
+    def stream(self, f):
+        sexp_to_stream(self, f)
+
+    @classmethod
+    def from_bytes(cls: Type[T_Program], blob: bytes) -> T_Program:
+        # this runs the program "1", which just returns the first argument.
+        # the first argument is the buffer we want to parse. This effectively
+        # leverages the rust parser and LazyNode, making it a lot faster to
+        # parse serialized programs into a python compatible structure
+        cost, ret = run_chia_program(
+            b"\x01",
+            blob,
+            50,
+            ALLOW_BACKREFS,
+        )
+        return cls.to(ret)
+
+    @classmethod
+    def fromhex(cls: Type[T_Program], hexstr: str) -> T_Program:
+        return cls.from_bytes(hexstr_to_bytes(hexstr))
+
+    @classmethod
+    def from_json_dict(cls: Type[Program], json_dict: Any) -> Program:
+        if isinstance(json_dict, cls):
+            return json_dict
+        item = hexstr_to_bytes(json_dict)
+        return cls.from_bytes(item)
+
+    def to_json_dict(self) -> str:
+        return f"0x{self}"
+
+    def __bytes__(self) -> bytes:
+        f = io.BytesIO()
+        self.stream(f)  # noqa
+        return f.getvalue()
+
+    def __str__(self) -> str:
+        return bytes(self).hex()
+
+    def at(self, position: str) -> Program:
+        """
+        Take a string of only `f` and `r` characters and follow the corresponding path.
+
+        Example:
+
+        `assert Program.to(17) == Program.to([10, 20, 30, [15, 17], 40, 50]).at("rrrfrf")`
+
+        """
+        v = self
+        for c in position.lower():
+            if c == "f":
+                v = v.first()
+            elif c == "r":
+                v = v.rest()
+            else:
+                raise ValueError(f"`at` got illegal character `{c}`. Only `f` & `r` allowed")
+        return v
+
+    def replace(self: T_Program, **kwargs: Any) -> T_Program:
+        """
+        Create a new program replacing the given paths (using `at` syntax).
+        Example:
+        ```
+        >>> p1 = Program.to([100, 200, 300])
+        >>> print(p1.replace(f=105) == Program.to([105, 200, 300]))
+        True
+        >>> print(p1.replace(rrf=[301, 302]) == Program.to([100, 200, [301, 302]]))
+        True
+        >>> print(p1.replace(f=105, rrf=[301, 302]) == Program.to([105, 200, [301, 302]]))
+        True
+        ```
+
+        This is a convenience method intended for use in the wallet or command-line hacks where
+        it would be easier to morph elements of an existing clvm object tree than to rebuild
+        one from scratch.
+
+        Note that `Program` objects are immutable. This function returns a new object; the
+        original is left as-is.
+        """
+        return _sexp_replace(self, self.to, **kwargs)
+
+    def get_tree_hash_precalc(self, *args: bytes32) -> bytes32:
+        """
+        Any values in `args` that appear in the tree
+        are presumed to have been hashed already.
+        """
+        return sha256_treehash(self, set(args))
+
+    def get_tree_hash(self) -> bytes32:
+        return bytes32(tree_hash(bytes(self)))
+
+    def _run(self, max_cost: int, flags: int, args: Any) -> Tuple[int, Program]:
+        prog_args = Program.to(args)
+        cost, r = run_chia_program(self.as_bin(), prog_args.as_bin(), max_cost, flags)
+        return cost, Program.to(r)
+
+    def run_with_cost(self, max_cost: int, args: Any, flags=DEFAULT_FLAGS) -> Tuple[int, Program]:
+        # when running puzzles in the wallet, default to enabling all soft-forks
+        # as well as enabling mempool-mode (i.e. strict mode)
+        return self._run(max_cost, flags, args)
+
+    def run(self, args: Any, max_cost=INFINITE_COST, flags=DEFAULT_FLAGS) -> Program:
+        cost, r = self._run(max_cost, flags, args)
+        return r
+
+    def run_with_flags(self, max_cost: int, flags: int, args: Any) -> Tuple[int, Program]:
+        return self._run(max_cost, flags, args)
+
+    # Replicates the curry function from clvm_tools, taking advantage of *args
+    # being a list.  We iterate through args in reverse building the code to
+    # create a clvm list.
+    #
+    # Given arguments to a function addressable by the '1' reference in clvm
+    #
+    # fixed_args = 1
+    #
+    # Each arg is prepended as fixed_args = (c (q . arg) fixed_args)
+    #
+    # The resulting argument list is interpreted with apply (2)
+    #
+    # (2 (1 . self) rest)
+    #
+    # Resulting in a function which places its own arguments after those
+    # curried in in the form of a proper list.
+    def curry(self, *args) -> Program:
+        fixed_args: Any = 1
+        for arg in reversed(args):
+            fixed_args = [4, (1, arg), fixed_args]
+        return Program.to([2, (1, self), fixed_args])
+
+    def uncurry(self) -> Tuple[Program, Program]:
+        def match(o: CLVMStorage, expected: bytes) -> None:
+            if o.atom != expected:
+                raise ValueError(f"expected: {expected.hex()}")
+
+        try:
+            # (2 (1 . <mod>) <args>)
+            ev, quoted_inner, args_list = self.as_iter()
+            match(ev, b"\x02")
+            if TYPE_CHECKING:
+                # this being False is presently handled in the TypeError exception handler below
+                assert quoted_inner.pair is not None
+            match(quoted_inner.pair[0], b"\x01")
+            mod = quoted_inner.pair[1]
+            args = []
+            while args_list.pair is not None:
+                # (4 (1 . <arg>) <rest>)
+                cons, quoted_arg, rest = args_list.as_iter()
+                match(cons, b"\x04")
+                if TYPE_CHECKING:
+                    # this being False is presently handled in the TypeError exception handler below
+                    assert quoted_arg.pair is not None
+                match(quoted_arg.pair[0], b"\x01")
+                args.append(quoted_arg.pair[1])
+                args_list = rest
+            match(args_list, b"\x01")
+            return Program.to(mod), Program.to(args)
+        except ValueError:  # too many values to unpack
+            # when unpacking as_iter()
+            # or when a match() fails
+            return self, self.to(0)
+        except TypeError:  # NoneType not subscriptable
+            # when an object is not a pair or atom as expected
+            return self, self.to(0)
+        except EvalError:  # first of non-cons
+            # when as_iter() fails
+            return self, self.to(0)
+
+    def as_int(self) -> int:
+        return int_from_bytes(self.as_atom())
+
+    def as_atom(self) -> bytes:
+        ret: Optional[bytes] = self.atom
+        if ret is None:
+            raise ValueError("expected atom")
+        return ret
+
+    def __deepcopy__(self, memo):
+        return type(self).from_bytes(bytes(self))
+
+    EvalError = EvalError
+
+
+def _tree_hash(node: SExp, precalculated: Set[bytes32]) -> bytes32:
+    """
+    Hash values in `precalculated` are presumed to have been hashed already.
+    """
+    if node.listp():
+        left = _tree_hash(node.first(), precalculated)
+        right = _tree_hash(node.rest(), precalculated)
+        s = b"\2" + left + right
+    else:
+        # node.listp() is False so must be an atom
+        atom: bytes = node.as_atom()  # type: ignore[assignment]
+        if atom in precalculated:
+            return bytes32(atom)
+        s = b"\1" + atom
+    return bytes32(std_hash(s))
+
+
+NIL = Program.from_bytes(b"\x80")
+
+
+# real return type is more like Union[T_Program, CastableType] when considering corner and terminal cases
+def _sexp_replace(sexp: T_CLVMStorage, to_sexp: Callable[[Any], T_Program], **kwargs: Any) -> T_Program:
+    # if `kwargs == {}` then `return sexp` unchanged
+    if len(kwargs) == 0:
+        # yes, the terminal case is hinted incorrectly for now
+        return sexp  # type: ignore[return-value]
+
+    if "" in kwargs:
+        if len(kwargs) > 1:
+            raise ValueError("conflicting paths")
+        return kwargs[""]
+
+    # we've confirmed that no `kwargs` is the empty string.
+    # Now split `kwargs` into two groups: those
+    # that start with `f` and those that start with `r`
+
+    args_by_prefix: Dict[str, Dict[str, Any]] = {}
+    for k, v in kwargs.items():
+        c = k[0]
+        if c not in "fr":
+            raise ValueError("bad path containing %s: must only contain `f` and `r`")
+        args_by_prefix.setdefault(c, dict())[k[1:]] = v
+
+    pair = sexp.pair
+    if pair is None:
+        raise ValueError("path into atom")
+
+    # recurse down the tree
+    new_f = _sexp_replace(pair[0], to_sexp, **args_by_prefix.get("f", {}))
+    new_r = _sexp_replace(pair[1], to_sexp, **args_by_prefix.get("r", {}))
+
+    return to_sexp((new_f, new_r))

chia/types/blockchain_format/proof_of_space.py

@@ -0,0 +1,135 @@
+from __future__ import annotations
+
+import logging
+from typing import Optional, cast
+
+import chia_rs
+from bitstring import BitArray
+from chia_rs import AugSchemeMPL, G1Element, PrivateKey
+from chiapos import Verifier
+
+from chia.consensus.constants import ConsensusConstants
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.hash import std_hash
+from chia.util.ints import uint32
+
+ProofOfSpace = chia_rs.ProofOfSpace
+
+log = logging.getLogger(__name__)
+
+
+def get_plot_id(pos: ProofOfSpace) -> bytes32:
+    assert pos.pool_public_key is None or pos.pool_contract_puzzle_hash is None
+    if pos.pool_public_key is None:
+        assert pos.pool_contract_puzzle_hash is not None
+        return calculate_plot_id_ph(pos.pool_contract_puzzle_hash, pos.plot_public_key)
+    return calculate_plot_id_pk(pos.pool_public_key, pos.plot_public_key)
+
+
+def verify_and_get_quality_string(
+    pos: ProofOfSpace,
+    constants: ConsensusConstants,
+    original_challenge_hash: bytes32,
+    signage_point: bytes32,
+    *,
+    height: uint32,
+) -> Optional[bytes32]:
+    # Exactly one of (pool_public_key, pool_contract_puzzle_hash) must not be None
+    if (pos.pool_public_key is None) and (pos.pool_contract_puzzle_hash is None):
+        log.error("Expected pool public key or pool contract puzzle hash but got neither")
+        return None
+    if (pos.pool_public_key is not None) and (pos.pool_contract_puzzle_hash is not None):
+        log.error("Expected pool public key or pool contract puzzle hash but got both")
+        return None
+    if pos.size < constants.MIN_PLOT_SIZE:
+        log.error("Plot size is lower than the minimum")
+        return None
+    if pos.size > constants.MAX_PLOT_SIZE:
+        log.error("Plot size is higher than the maximum")
+        return None
+    plot_id: bytes32 = get_plot_id(pos)
+    new_challenge: bytes32 = calculate_pos_challenge(plot_id, original_challenge_hash, signage_point)
+
+    if new_challenge != pos.challenge:
+        log.error("Calculated pos challenge doesn't match the provided one")
+        return None
+    prefix_bits = calculate_prefix_bits(constants, height)
+    if not passes_plot_filter(prefix_bits, plot_id, original_challenge_hash, signage_point):
+        log.error("Did not pass the plot filter")
+        return None
+
+    return get_quality_string(pos, plot_id)
+
+
+def get_quality_string(pos: ProofOfSpace, plot_id: bytes32) -> Optional[bytes32]:
+    quality_str = Verifier().validate_proof(plot_id, pos.size, pos.challenge, bytes(pos.proof))
+    if not quality_str:
+        return None
+    return bytes32(quality_str)
+
+
+def passes_plot_filter(
+    prefix_bits: int,
+    plot_id: bytes32,
+    challenge_hash: bytes32,
+    signage_point: bytes32,
+) -> bool:
+    # this is possible when using non-mainnet constants with a low
+    # NUMBER_ZERO_BITS_PLOT_FILTER constant and activating sufficient plot
+    # filter reductions
+    if prefix_bits == 0:
+        return True
+
+    plot_filter = BitArray(calculate_plot_filter_input(plot_id, challenge_hash, signage_point))
+    # TODO: compensating for https://github.com/scott-griffiths/bitstring/issues/248
+    return cast(bool, plot_filter[:prefix_bits].uint == 0)
+
+
+def calculate_prefix_bits(constants: ConsensusConstants, height: uint32) -> int:
+    prefix_bits = int(constants.NUMBER_ZERO_BITS_PLOT_FILTER)
+    if height >= constants.PLOT_FILTER_32_HEIGHT:
+        prefix_bits -= 4
+    elif height >= constants.PLOT_FILTER_64_HEIGHT:
+        prefix_bits -= 3
+    elif height >= constants.PLOT_FILTER_128_HEIGHT:
+        prefix_bits -= 2
+    elif height >= constants.HARD_FORK_HEIGHT:
+        prefix_bits -= 1
+
+    return max(0, prefix_bits)
+
+
+def calculate_plot_filter_input(plot_id: bytes32, challenge_hash: bytes32, signage_point: bytes32) -> bytes32:
+    return std_hash(plot_id + challenge_hash + signage_point)
+
+
+def calculate_pos_challenge(plot_id: bytes32, challenge_hash: bytes32, signage_point: bytes32) -> bytes32:
+    return std_hash(calculate_plot_filter_input(plot_id, challenge_hash, signage_point))
+
+
+def calculate_plot_id_pk(
+    pool_public_key: G1Element,
+    plot_public_key: G1Element,
+) -> bytes32:
+    return std_hash(bytes(pool_public_key) + bytes(plot_public_key))
+
+
+def calculate_plot_id_ph(
+    pool_contract_puzzle_hash: bytes32,
+    plot_public_key: G1Element,
+) -> bytes32:
+    return std_hash(bytes(pool_contract_puzzle_hash) + bytes(plot_public_key))
+
+
+def generate_taproot_sk(local_pk: G1Element, farmer_pk: G1Element) -> PrivateKey:
+    taproot_message: bytes = bytes(local_pk + farmer_pk) + bytes(local_pk) + bytes(farmer_pk)
+    taproot_hash: bytes32 = std_hash(taproot_message)
+    return AugSchemeMPL.key_gen(taproot_hash)
+
+
+def generate_plot_public_key(local_pk: G1Element, farmer_pk: G1Element, include_taproot: bool = False) -> G1Element:
+    if include_taproot:
+        taproot_sk: PrivateKey = generate_taproot_sk(local_pk, farmer_pk)
+        return local_pk + farmer_pk + taproot_sk.get_g1()
+    else:
+        return local_pk + farmer_pk

chia/types/blockchain_format/reward_chain_block.py

@@ -0,0 +1,6 @@
+from __future__ import annotations
+
+import chia_rs
+
+RewardChainBlock = chia_rs.RewardChainBlock
+RewardChainBlockUnfinished = chia_rs.RewardChainBlockUnfinished

chia/types/blockchain_format/serialized_program.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+import chia_rs
+
+SerializedProgram = chia_rs.Program

chia/types/blockchain_format/sized_bytes.py

@@ -0,0 +1,11 @@
+from __future__ import annotations
+
+import chia_rs.sized_bytes
+
+bytes4 = chia_rs.sized_bytes.bytes4
+bytes8 = chia_rs.sized_bytes.bytes8
+bytes32 = chia_rs.sized_bytes.bytes32
+bytes48 = chia_rs.sized_bytes.bytes48
+bytes96 = chia_rs.sized_bytes.bytes96
+bytes100 = chia_rs.sized_bytes.bytes100
+bytes480 = chia_rs.sized_bytes.bytes480

chia/types/blockchain_format/slots.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+import chia_rs
+
+ChallengeBlockInfo = chia_rs.ChallengeBlockInfo
+ChallengeChainSubSlot = chia_rs.ChallengeChainSubSlot
+InfusedChallengeChainSubSlot = chia_rs.InfusedChallengeChainSubSlot
+RewardChainSubSlot = chia_rs.RewardChainSubSlot
+SubSlotProofs = chia_rs.SubSlotProofs

chia/types/blockchain_format/sub_epoch_summary.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+import chia_rs
+
+SubEpochSummary = chia_rs.SubEpochSummary

chia/types/blockchain_format/tree_hash.py

@@ -0,0 +1,72 @@
+"""
+This is an implementation of `sha256_treehash`, used to calculate
+puzzle hashes in clvm.
+
+This implementation goes to great pains to be non-recursive so we don't
+have to worry about blowing out the python stack.
+"""
+
+from __future__ import annotations
+
+from typing import Callable, List, Optional, Set, Union
+
+from clvm.CLVMObject import CLVMStorage
+from clvm.SExp import SExp
+
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.hash import std_hash
+
+ValueType = Union[bytes, CLVMStorage]
+ValueStackType = List[ValueType]
+Op = Callable[[ValueStackType, "OpStackType", Set[bytes32]], None]
+OpStackType = List[Op]
+
+
+def sha256_treehash(sexp: CLVMStorage, precalculated: Optional[Set[bytes32]] = None) -> bytes32:
+    """
+    Hash values in `precalculated` are presumed to have been hashed already.
+    """
+
+    if precalculated is None:
+        precalculated = set()
+
+    def handle_sexp(sexp_stack: ValueStackType, op_stack: OpStackType, precalculated: Set[bytes32]) -> None:
+        # just trusting it is right, otherwise we get an attribute error
+        sexp: SExp = sexp_stack.pop()  # type: ignore[assignment]
+        if sexp.pair:
+            p0, p1 = sexp.pair
+            sexp_stack.append(p0)
+            sexp_stack.append(p1)
+            op_stack.append(handle_pair)
+            op_stack.append(handle_sexp)
+            op_stack.append(roll)
+            op_stack.append(handle_sexp)
+        else:
+            # not a pair, so an atom
+            atom: bytes = sexp.atom  # type: ignore[assignment]
+            if atom in precalculated:
+                r = atom
+            else:
+                r = std_hash(b"\1" + atom)
+            sexp_stack.append(r)
+
+    def handle_pair(sexp_stack: ValueStackType, op_stack: OpStackType, precalculated: Set[bytes32]) -> None:
+        # just trusting it is right, otherwise we get a type error
+        p0: bytes = sexp_stack.pop()  # type: ignore[assignment]
+        p1: bytes = sexp_stack.pop()  # type: ignore[assignment]
+        sexp_stack.append(std_hash(b"\2" + p0 + p1))
+
+    def roll(sexp_stack: ValueStackType, op_stack: OpStackType, precalculated: Set[bytes32]) -> None:
+        p0 = sexp_stack.pop()
+        p1 = sexp_stack.pop()
+        sexp_stack.append(p0)
+        sexp_stack.append(p1)
+
+    sexp_stack: ValueStackType = [sexp]
+    op_stack: List[Op] = [handle_sexp]
+    while len(op_stack) > 0:
+        op = op_stack.pop()
+        op(sexp_stack, op_stack, precalculated)
+    # just trusting it is right, otherwise we get some error, probably
+    result: bytes = sexp_stack[0]  # type: ignore[assignment]
+    return bytes32(result)

chia/types/blockchain_format/vdf.py

@@ -0,0 +1,86 @@
+from __future__ import annotations
+
+import logging
+import traceback
+from enum import IntEnum
+from functools import lru_cache
+from typing import Optional
+
+from chia_rs import VDFInfo, VDFProof
+from chiavdf import create_discriminant, verify_n_wesolowski
+
+from chia.consensus.constants import ConsensusConstants
+from chia.types.blockchain_format.classgroup import ClassgroupElement
+from chia.types.blockchain_format.sized_bytes import bytes32, bytes100
+from chia.util.ints import uint8, uint64
+
+log = logging.getLogger(__name__)
+
+__all__ = ["VDFInfo", "VDFProof"]
+
+
+@lru_cache(maxsize=200)
+def get_discriminant(challenge: bytes32, size_bites: int) -> int:
+    return int(
+        create_discriminant(challenge, size_bites),
+        16,
+    )
+
+
+@lru_cache(maxsize=1000)
+def verify_vdf(
+    disc: int,
+    input_el: bytes100,
+    output: bytes,
+    number_of_iterations: uint64,
+    discriminant_size: int,
+    witness_type: uint8,
+) -> bool:
+    # TODO: chiavdf needs hinted
+    return verify_n_wesolowski(  # type:ignore[no-any-return]
+        str(disc),
+        input_el,
+        output,
+        number_of_iterations,
+        discriminant_size,
+        witness_type,
+    )
+
+
+def validate_vdf(
+    proof: VDFProof,
+    constants: ConsensusConstants,
+    input_el: ClassgroupElement,
+    info: VDFInfo,
+    target_vdf_info: Optional[VDFInfo] = None,
+) -> bool:
+    """
+    If target_vdf_info is passed in, it is compared with info.
+    """
+    if target_vdf_info is not None and info != target_vdf_info:
+        tb = traceback.format_stack()
+        log.error(f"{tb} INVALID VDF INFO. Have: {info} Expected: {target_vdf_info}")
+        return False
+    if proof.witness_type + 1 > constants.MAX_VDF_WITNESS_SIZE:
+        return False
+    try:
+        disc: int = get_discriminant(info.challenge, constants.DISCRIMINANT_SIZE_BITS)
+        # TODO: parallelize somehow, this might included multiple mini proofs (n weso)
+        return verify_vdf(
+            disc,
+            input_el.data,
+            info.output.data + bytes(proof.witness),
+            info.number_of_iterations,
+            constants.DISCRIMINANT_SIZE_BITS,
+            proof.witness_type,
+        )
+    except Exception:
+        return False
+
+
+# Stores, for a given VDF, the field that uses it.
+class CompressibleVDFField(IntEnum):
+    CC_EOS_VDF = 1
+    ICC_EOS_VDF = 2
+    CC_SP_VDF = 3
+    CC_IP_VDF = 4

chia/types/clvm_cost.py

@@ -0,0 +1,13 @@
+from __future__ import annotations
+
+from typing import NewType
+
+from chia.util.ints import uint64
+
+"""
+CLVM Cost is the cost to run a CLVM program on the CLVM.
+It is similar to transaction bytes in the Bitcoin, but some operations
+are charged a higher rate, depending on their arguments.
+"""
+
+CLVMCost = NewType("CLVMCost", uint64)

chia/types/coin_record.py

@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Optional
+
+from chia.protocols.wallet_protocol import CoinState
+from chia.types.blockchain_format.coin import Coin
+from chia.types.blockchain_format.sized_bytes import bytes32
+from chia.util.ints import uint32, uint64
+from chia.util.streamable import Streamable, streamable
+
+
+@streamable
+@dataclass(frozen=True)
+class CoinRecord(Streamable):
+    """
+    These are values that correspond to a CoinName that are used
+    in keeping track of the unspent database.
+    """
+
+    coin: Coin
+    confirmed_block_index: uint32
+    spent_block_index: uint32
+    coinbase: bool
+    timestamp: uint64  # Timestamp of the block at height confirmed_block_index
+
+    @property
+    def spent(self) -> bool:
+        return self.spent_block_index > 0
+
+    @property
+    def name(self) -> bytes32:
+        return self.coin.name()
+
+    @property
+    def coin_state(self) -> CoinState:
+        spent_h = None
+        if self.spent:
+            spent_h = self.spent_block_index
+        confirmed_height: Optional[uint32] = self.confirmed_block_index
+        if self.confirmed_block_index == 0 and self.timestamp == 0:
+            confirmed_height = None
+        return CoinState(self.coin, spent_h, confirmed_height)