charli3_dendrite 1.6.7.dev0__tar.gz → 1.6.7.dev1__tar.gz

{charli3_dendrite-1.6.7.dev0 → charli3_dendrite-1.6.7.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: charli3_dendrite
-Version: 1.6.7.dev0
+Version: 1.6.7.dev1
 Summary: 
 License-File: LICENSE
 Author: Elder Millenial

{charli3_dendrite-1.6.7.dev0 → charli3_dendrite-1.6.7.dev1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "charli3_dendrite"
-version = "1.6.7-dev0"
+version = "1.6.7-dev1"
 description = ""
 authors = ["Elder Millenial <eldermillenial@protonmail.com>"]
 readme = "README.md"
@@ -50,7 +50,7 @@ module = ["pycardano", "pycardano.*", "dotenv", "nox", "uplc", "uplc.*"]
 ignore_missing_imports = true
 
 [tool.bumpversion]
-current_version = "1.6.7-dev0"
+current_version = "1.6.7-dev1"
 parse = """(?x)
     (?P<major>\\d+)\\.
     (?P<minor>\\d+)\\.

{charli3_dendrite-1.6.7.dev0 → charli3_dendrite-1.6.7.dev1}/src/charli3_dendrite/backend/dbsync/__init__.py

@@ -214,7 +214,9 @@ AND txo.consumed_by_tx_id IS NULL"""
             datum_selector += """
 AND ma.policy = ANY(%(policies)b) AND ma.name = ANY(%(names)b)"""
 
+        # A stable order, so LIMIT / OFFSET pages neither skip nor repeat a row.
         datum_selector += """
+ORDER BY txo.id
 LIMIT %(limit)s
 OFFSET %(offset)s"""
 

charli3_dendrite-1.6.7.dev1/src/charli3_dendrite/lending/builtins.py

@@ -0,0 +1,20 @@
+"""The protocol modules shipped with the lending package, in one table.
+
+Each entry names the module that registers a protocol (never its bare package), and
+that module provides:
+
+- ``RATE_MODELS: tuple[type[RateModel], ...]``, the protocol's rate models, which
+  :mod:`charli3_dendrite.lending.rates` registers on its first lookup; and
+- ``market_source() -> MarketSource``, the protocol's market source, which
+  :mod:`charli3_dendrite.lending.markets` registers on its first use.
+
+Both registries keep a caller's own registration under the same key. No entry is
+imported until a registry is first used.
+"""
+
+from __future__ import annotations
+
+BUILTIN_PROTOCOL_PACKAGES: tuple[str, ...] = (
+    "charli3_dendrite.lending.fluidtokens_v4.market",
+    "charli3_dendrite.lending.liqwid.market",
+)

{charli3_dendrite-1.6.7.dev0 → charli3_dendrite-1.6.7.dev1}/src/charli3_dendrite/lending/danogo/oracles/forward.py

@@ -17,8 +17,8 @@ from charli3_dendrite.lending.danogo.oracles.redeemer import OracleUtxoType
 from charli3_dendrite.lending.danogo.oracles.reproduce import OracleLeaf
 from charli3_dendrite.lending.danogo.oracles.reproduce import leaf_forward_rates
 from charli3_dendrite.lending.danogo.oracles.reproduce import splash_lp_candidate
-from charli3_dendrite.lending.liqwid.datums import liqwid_oracle_feed_id
-from charli3_dendrite.lending.liqwid.datums import parse_liqwid_oracle_v2
+from charli3_dendrite.lending.liqwid.datums import POLICY_KEY_PREFIX
+from charli3_dendrite.lending.liqwid.datums import decode_oracle_feed
 from charli3_dendrite.lending.oracles.models import OraclePrice
 from charli3_dendrite.lending.oracles.models import OracleSource
 from charli3_dendrite.lending.oracles.models import PriceMap
@@ -57,9 +57,10 @@ def leaf_discriminator(otype: str, datum: str | None) -> str:
     Some source kinds live many-to-one behind a shared marker token at a common
     address, so the value alone cannot pin a UTxO; a stable datum field can:
 
-    * Liqwid V2 oracles -> ``updater_key:priced_asset``. Neither part is unique on
-      its own (one updater key spans many assets; one asset, e.g. ADA, can have
-      several feeds), but together they pin the UTxO.
+    * Liqwid V2 oracles -> the priced asset's key (``OracleFeedDatum.asset_key``:
+      the asset unit, or ``policy:<policy>`` for a policy-wide feed). Each priced
+      asset has exactly one unspent feed carrying the oracle token; the updater key
+      rotates and is not part of the identity.
     * Minswap pools -> the ``asset_a|asset_b`` pair (all pools carry one MSP token).
 
     Returns "" for kinds already pinned by a unique NFT (no datum disambiguation
@@ -69,7 +70,7 @@ def leaf_discriminator(otype: str, datum: str | None) -> str:
         return ""
     try:
         if otype == OracleUtxoType.TLIQWID_ORACLE_V2.name:
-            return f"{liqwid_oracle_feed_id(datum)}:{parse_liqwid_oracle_v2(datum)[0]}"
+            return decode_oracle_feed(datum).asset_key
         if otype == OracleUtxoType.TMINSWAP_LP.name:
             asset_a, _, asset_b, _ = parse_minswap_lp(datum)
             return f"{asset_a}|{asset_b}"
@@ -78,6 +79,32 @@ def leaf_discriminator(otype: str, datum: str | None) -> str:
     return ""
 
 
+def _handle_key(handle: LeafHandle) -> str:
+    """The identity ``handle.datum_key`` pins, in `leaf_discriminator`'s form.
+
+    A Liqwid oracle key in the earlier ``<updater>:<asset>`` form pins its asset
+    part; a ``policy:<policy>`` key is already in the current form.
+    """
+    key = handle.datum_key
+    if handle.otype == OracleUtxoType.TLIQWID_ORACLE_V2.name and not key.startswith(
+        POLICY_KEY_PREFIX,
+    ):
+        return key.rpartition(":")[2]
+    return key
+
+
+def leaf_matches_handle(handle: LeafHandle, datum: str | None) -> bool:
+    """Whether a leaf's datum carries the identity ``handle.datum_key`` pins.
+
+    True for every datum when the handle has no ``datum_key`` (its NFT alone pins
+    the UTxO). Otherwise the leaf's `leaf_discriminator` must equal the handle's key;
+    a Liqwid oracle key captured as ``<updater>:<asset>`` is compared by its asset.
+    """
+    if not handle.datum_key:
+        return True
+    return leaf_discriminator(handle.otype, datum) == _handle_key(handle)
+
+
 @dataclass(frozen=True)
 class LiveLeaf:
     """A source leaf as currently read on-chain: its parser type, datum, and value."""
@@ -206,6 +233,35 @@ def compose_cross_quote(
     return collat_price, intermediate_to_quote
 
 
+def _leaf_addresses(handle: LeafHandle) -> list[str]:
+    """The addresses a handle's leaf is read from.
+
+    A Liqwid oracle leaf is read at ``handle.address`` and at every Liqwid oracle
+    validator of the bundled deployment, captured address first, each address once:
+    Liqwid binds a feed by oracle token and asset, whatever its validator, and the
+    captured address stays read when the deployment no longer lists it. Every other
+    kind is read at ``handle.address`` only.
+    """
+    if handle.otype != OracleUtxoType.TLIQWID_ORACLE_V2.name:
+        return [handle.address]
+    # Imported here so that importing this module loads no Liqwid deployment.
+    from charli3_dendrite.lending.liqwid.indexing import LiqwidKind
+    from charli3_dendrite.lending.liqwid.indexing import liqwid_selectors
+
+    return list(
+        dict.fromkeys(
+            [
+                handle.address,
+                *(
+                    selector.address
+                    for selector in liqwid_selectors()
+                    if selector.kind is LiqwidKind.ORACLE
+                ),
+            ],
+        ),
+    )
+
+
 def resolve_leaf_info(
     backend: AbstractBackend,
     handle: LeafHandle,
@@ -214,7 +270,9 @@ def resolve_leaf_info(
 
     A unique identifying NFT yields a single match; kinds that share a marker token
     across many feeds at one address (e.g. Liqwid V2 oracles) are narrowed by
-    `handle.datum_key` -- the stable asset-identity parsed from each candidate's datum.
+    `handle.datum_key` -- the stable asset-identity parsed from each candidate's datum
+    (`leaf_matches_handle`). A Liqwid oracle leaf is looked up at ``handle.address``
+    and at every Liqwid oracle validator (`_leaf_addresses`).
     Returns None unless exactly one UTxO matches, so the caller never reads the wrong
     feed. This is the shared resolution both `read_live_leaf` (forward pricing) and the
     create-loan snapshot (full-UTxO assembly) rely on.
@@ -222,18 +280,17 @@ def resolve_leaf_info(
     want = (handle.nft_policy + handle.nft_name) if handle.nft_policy else None
     rows = list(
         backend.get_pool_utxos(
-            addresses=[handle.address],
+            addresses=_leaf_addresses(handle),
             assets=[want] if want else None,
             historical=False,
         ),
     )
-    matches = [info for info in rows if want is None or want in info.assets.root]
-    if handle.datum_key:
-        matches = [
-            info
-            for info in matches
-            if leaf_discriminator(handle.otype, info.datum_cbor) == handle.datum_key
-        ]
+    matches = [
+        info
+        for info in rows
+        if (want is None or want in info.assets.root)
+        and leaf_matches_handle(handle, info.datum_cbor)
+    ]
     if len(matches) != 1:
         return None
     return matches[0]

{charli3_dendrite-1.6.7.dev0 → charli3_dendrite-1.6.7.dev1}/src/charli3_dendrite/lending/danogo/oracles/locator.py

@@ -50,6 +50,8 @@ class LeafHandle:
     `datum_key` is a further discriminator for kinds that share one marker token across
     many feeds (e.g. Liqwid V2 oracles): the stable asset-identity parsed from the leaf
     datum (see `forward.leaf_discriminator`). Empty when the NFT alone pins the UTxO.
+    A Liqwid oracle leaf is identified by its token and `datum_key` alone and is read
+    at every Liqwid oracle validator; its `address` is where it was captured.
     """
 
     otype: str

{charli3_dendrite-1.6.7.dev0 → charli3_dendrite-1.6.7.dev1}/src/charli3_dendrite/lending/danogo/oracles/reproduce.py

@@ -47,8 +47,8 @@ from charli3_dendrite.lending.danogo.oracles.leaves import parse_minswap_lp
 from charli3_dendrite.lending.danogo.oracles.leaves import parse_splash_cpamm_g3
 from charli3_dendrite.lending.danogo.oracles.leaves import splash_lp_token_price
 from charli3_dendrite.lending.danogo.oracles.redeemer import OracleUtxoType
+from charli3_dendrite.lending.liqwid.datums import decode_oracle_feed
 from charli3_dendrite.lending.liqwid.datums import parse_liqwid_market_state
-from charli3_dendrite.lending.liqwid.datums import parse_liqwid_oracle_v2
 
 # Liqwid market qToken: the on-chain price divides the field-9 exchange rate by the
 # underlying's (cent-denominated) price; that constant is folded into the leaf rate so
@@ -96,7 +96,7 @@ def leaf_forward_rates(leaf: OracleLeaf) -> List[Tuple[str, Fraction]]:
             num, den = parse_danogo_staking_rate(datum)
             out.append(("stake", Fraction(num, den)))
         elif leaf.otype == OracleUtxoType.TLIQWID_ORACLE_V2 and datum is not None:
-            _, (num, den) = parse_liqwid_oracle_v2(datum)
+            num, den = decode_oracle_feed(datum).price
             out.append(("liqv2", Fraction(num, den)))
         elif leaf.otype == OracleUtxoType.TDJED and datum is not None:
             _, (num, den) = parse_djed(datum)

{charli3_dendrite-1.6.7.dev0 → charli3_dendrite-1.6.7.dev1}/src/charli3_dendrite/lending/danogo/transactions/_common.py

@@ -47,7 +47,7 @@ from charli3_dendrite.lending.danogo.oracles.deployments import (
 from charli3_dendrite.lending.danogo.oracles.forward import INTERMEDIATE_QUOTE
 from charli3_dendrite.lending.danogo.oracles.forward import LiveLeaf
 from charli3_dendrite.lending.danogo.oracles.forward import compose_cross_quote
-from charli3_dendrite.lending.danogo.oracles.forward import leaf_discriminator
+from charli3_dendrite.lending.danogo.oracles.forward import leaf_matches_handle
 from charli3_dendrite.lending.danogo.oracles.forward import replay_recipe
 from charli3_dendrite.lending.danogo.oracles.leaves import parse_orcfax_fs
 from charli3_dendrite.lending.danogo.oracles.locator import Recipe
@@ -145,18 +145,17 @@ def _leaf_for_handle(leaves: list[Utxo], handle: LeafHandle) -> Utxo | None:
     """Find the resolved source leaf a recipe step's handle points at.
 
     Matches by the handle's identifying NFT (policy + name) and, when present, the
-    datum discriminator that pins kinds sharing one marker token across many feeds.
+    datum discriminator that pins kinds sharing one marker token across many feeds
+    (`leaf_matches_handle`, as `resolve_leaf_info`). None unless exactly one leaf
+    matches.
     """
-    for u in leaves:
-        if handle.nft_policy and not u.holds(handle.nft_policy, handle.nft_name):
-            continue
-        if (
-            handle.datum_key
-            and leaf_discriminator(handle.otype, u.datum) != handle.datum_key
-        ):
-            continue
-        return u
-    return None
+    matches = [
+        u
+        for u in leaves
+        if (not handle.nft_policy or u.holds(handle.nft_policy, handle.nft_name))
+        and leaf_matches_handle(handle, u.datum)
+    ]
+    return matches[0] if len(matches) == 1 else None
 
 
 def _resolve_recipe(

charli3_dendrite-1.6.7.dev1/src/charli3_dendrite/lending/fetch.py

@@ -0,0 +1,58 @@
+"""Backend reads shared by the protocol loaders.
+
+A protocol loader fetches every unspent UTxO at a script address and classifies each
+row with its own parser; the paging, the out-ref de-duplication and the default
+evaluation time are the same for every protocol and live here.
+"""
+
+from __future__ import annotations
+
+import time
+from typing import TYPE_CHECKING
+from typing import Final
+
+if TYPE_CHECKING:
+    from charli3_dendrite.backend.backend_base import AbstractBackend
+    from charli3_dendrite.dataclasses.models import PoolStateInfo
+
+PAGE_SIZE: Final[int] = 1000
+
+
+def unspent_utxos(
+    backend: AbstractBackend,
+    address: str,
+    *,
+    page_size: int = PAGE_SIZE,
+) -> list[PoolStateInfo]:
+    """Every unspent UTxO the backend returns for ``address``, once per out-ref.
+
+    Pages through ``get_pool_utxos`` and terminates on a short page or on a page that
+    adds no new out-ref, so a backend that ignores ``page`` and returns the same rows
+    again ends the loop. Rows are de-duplicated by out-ref, keeping the first row
+    returned, since the backend pages with LIMIT / OFFSET. Rows keep the backend's
+    order.
+    """
+    rows_by_ref: dict[tuple[str, int], PoolStateInfo] = {}
+    page = 0
+    while True:
+        rows = list(
+            backend.get_pool_utxos(
+                addresses=[address],
+                limit=page_size,
+                page=page,
+                historical=False,
+            ),
+        )
+        before = len(rows_by_ref)
+        for info in rows:
+            rows_by_ref.setdefault((info.tx_hash, info.tx_index), info)
+        if len(rows) < page_size or len(rows_by_ref) == before:
+            return list(rows_by_ref.values())
+        page += 1
+
+
+def resolve_now_ms(now_ms: int | None) -> int:
+    """``now_ms`` (POSIX ms), or the current time when it is None."""
+    if now_ms is None:
+        return int(time.time() * 1000)
+    return now_ms

{charli3_dendrite-1.6.7.dev0 → charli3_dendrite-1.6.7.dev1}/src/charli3_dendrite/lending/fluidtokens_v4/indexing.py

@@ -13,13 +13,6 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Union
 
-import cbor2  # type: ignore[import-not-found]
-from pycardano import Address
-from pycardano import ScriptHash
-from pycardano.exception import DecodingException
-from pycardano.exception import DeserializeException
-from pycardano.exception import InvalidAddressInputException
-
 from charli3_dendrite.dataclasses.models import PoolSelector
 from charli3_dendrite.dataclasses.models import PoolStateInfo
 from charli3_dendrite.lending.fluidtokens_v4 import constants as c
@@ -32,6 +25,8 @@ from charli3_dendrite.lending.fluidtokens_v4.state import FluidV4PoolManagerStat
 from charli3_dendrite.lending.fluidtokens_v4.state import FluidV4PoolState
 from charli3_dendrite.lending.fluidtokens_v4.state import FluidV4RequestState
 from charli3_dendrite.lending.fluidtokens_v4.state import identity_name
+from charli3_dendrite.lending.units import DECODE_ERRORS
+from charli3_dendrite.lending.units import script_credential
 from charli3_dendrite.lending.units import script_payment_address
 
 FluidV4State = Union[
@@ -67,18 +62,6 @@ _STATE_CLASS: dict[EntityKind, type[FluidV4State]] = {
     EntityKind.LOCKED_BORROWER_MANAGER: FluidV4LockedBorrowerState,
 }
 
-# Everything a malformed record can raise while its datum is decoded. Truncated CBOR
-# raises cbor2's end-of-stream error, which is not a ValueError.
-DECODE_ERRORS = (
-    cbor2.CBORDecodeError,
-    DeserializeException,
-    ValueError,
-    TypeError,
-    KeyError,
-    IndexError,
-    AttributeError,
-)
-
 
 @dataclass(frozen=True)
 class EntitySelector:
@@ -138,28 +121,6 @@ def entity_selectors(
     }
 
 
-def script_credential(address: str) -> str | None:
-    """Payment script hash (hex) of a bech32 address; None for any other address.
-
-    Every V4 entity sits at a script credential, so a key-hash payment part (even one
-    whose bytes equal a V4 script hash) returns None, as does an unparseable address.
-    pycardano asserts key-hash sizes and decodes a bech32 Byron header as CBOR, so a
-    malformed address can also raise ``AssertionError`` or ``DeserializeException``.
-    """
-    try:
-        part = Address.decode(address).payment_part
-    except (
-        AssertionError,
-        DecodingException,
-        DeserializeException,
-        InvalidAddressInputException,
-        TypeError,
-        ValueError,
-    ):
-        return None
-    return part.payload.hex() if isinstance(part, ScriptHash) else None
-
-
 def parse_utxo(
     info: PoolStateInfo,
     selectors: Mapping[EntityKind, EntitySelector] | None = None,

{charli3_dendrite-1.6.7.dev0 → charli3_dendrite-1.6.7.dev1}/src/charli3_dendrite/lending/fluidtokens_v4/loader.py

@@ -12,12 +12,14 @@ that matches exact addresses the snapshot comes back empty.
 
 from __future__ import annotations
 
-import time
 from dataclasses import dataclass
 from typing import TYPE_CHECKING
 from typing import TypeVar
 
 from charli3_dendrite.lending.base import LendingBook
+from charli3_dendrite.lending.fetch import PAGE_SIZE
+from charli3_dendrite.lending.fetch import resolve_now_ms
+from charli3_dendrite.lending.fetch import unspent_utxos
 from charli3_dendrite.lending.fluidtokens_v4.constants import resolve_config
 from charli3_dendrite.lending.fluidtokens_v4.indexing import EntityKind
 from charli3_dendrite.lending.fluidtokens_v4.indexing import EntitySelector
@@ -37,8 +39,6 @@ if TYPE_CHECKING:
     from charli3_dendrite.lending.fluidtokens_v4.datums import ConfigDatum
     from charli3_dendrite.lending.oracles.models import PriceMap
 
-PAGE_SIZE = 1000
-
 _T = TypeVar("_T")
 
 
@@ -50,33 +50,16 @@ def fetch_entities(
 ) -> list[FluidV4State]:
     """Every unspent UTxO at ``selector``'s credential that parses as its kind.
 
-    Pages through ``get_pool_utxos`` and terminates on a short page or on a page that
-    adds no new out-ref, so a backend that ignores ``page`` and returns the same rows
-    again ends the loop. Pages are de-duplicated by out-ref, since the backend pages
-    with LIMIT / OFFSET. Sorted by out-ref.
+    The rows are those of :func:`~charli3_dendrite.lending.fetch.unspent_utxos`: every
+    page, once per out-ref. Sorted by out-ref.
     """
     only = {selector.kind: selector}
     found: dict[str, FluidV4State] = {}
-    seen: set[tuple[str, int]] = set()
-    page = 0
-    while True:
-        rows = list(
-            backend.get_pool_utxos(
-                addresses=[selector.address],
-                limit=page_size,
-                page=page,
-                historical=False,
-            ),
-        )
-        before = len(seen)
-        for info in rows:
-            seen.add((info.tx_hash, info.tx_index))
-            state = parse_utxo(info, only)
-            if state is not None:
-                found.setdefault(state.out_ref, state)
-        if len(rows) < page_size or len(seen) == before:
-            return [found[ref] for ref in sorted(found)]
-        page += 1
+    for info in unspent_utxos(backend, selector.address, page_size=page_size):
+        state = parse_utxo(info, only)
+        if state is not None:
+            found.setdefault(state.out_ref, state)
+    return [found[ref] for ref in sorted(found)]
 
 
 def link_loans(
@@ -134,8 +117,7 @@ def snapshot(
 
     ``now_ms`` (POSIX ms) is the loans' evaluation time; it defaults to now.
     """
-    if now_ms is None:
-        now_ms = int(time.time() * 1000)
+    now_ms = resolve_now_ms(now_ms)
     config = resolve_config(backend)
     fetched = {
         kind: fetch_entities(backend, selector)

{charli3_dendrite-1.6.7.dev0 → charli3_dendrite-1.6.7.dev1}/src/charli3_dendrite/lending/fluidtokens_v4/market.py

@@ -7,7 +7,6 @@ number comes from the datum and the contract-exact maths.
 
 from __future__ import annotations
 
-import time
 from fractions import Fraction
 from typing import TYPE_CHECKING
 from typing import Any
@@ -22,6 +21,7 @@ from charli3_dendrite.lending.fluidtokens_v4.indexing import EntityKind
 from charli3_dendrite.lending.fluidtokens_v4.indexing import entity_selectors
 from charli3_dendrite.lending.fluidtokens_v4.indexing import parse_utxo
 from charli3_dendrite.lending.fluidtokens_v4.rates import PROTOCOL_NAME
+from charli3_dendrite.lending.fluidtokens_v4.rates import RATE_MODELS  # noqa: F401
 from charli3_dendrite.lending.fluidtokens_v4.rates import FluidAmortizedRate
 from charli3_dendrite.lending.fluidtokens_v4.rates import FluidFlatTermRate
 from charli3_dendrite.lending.fluidtokens_v4.rates import FluidPerpetualRate
@@ -37,6 +37,7 @@ from charli3_dendrite.lending.fluidtokens_v4.state import names_under
 from charli3_dendrite.lending.fluidtokens_v4.transactions.oracle import has_oracle
 from charli3_dendrite.lending.markets import LendingSnapshot
 from charli3_dendrite.lending.markets import WatchSpec
+from charli3_dendrite.lending.markets import convertible_views
 from charli3_dendrite.lending.normalized import BorrowRequest
 from charli3_dendrite.lending.normalized import CollateralHolding
 from charli3_dendrite.lending.normalized import CollateralTerms
@@ -47,6 +48,7 @@ from charli3_dendrite.lending.normalized import LendingPosition
 from charli3_dendrite.lending.normalized import Origin
 from charli3_dendrite.lending.normalized import Party
 from charli3_dendrite.lending.normalized import PartyKind
+from charli3_dendrite.lending.normalized import as_parse_error
 from charli3_dendrite.lending.oracles.models import OracleRef
 from charli3_dendrite.lending.oracles.models import OracleSource
 from charli3_dendrite.lending.units import constr
@@ -58,6 +60,8 @@ if TYPE_CHECKING:
     from charli3_dendrite.lending.fluidtokens_v4.datums import CollateralAsset
     from charli3_dendrite.lending.fluidtokens_v4.datums import ConfigDatum
     from charli3_dendrite.lending.fluidtokens_v4.state import FluidV4PoolManagerState
+    from charli3_dendrite.lending.markets import ParseContext
+    from charli3_dendrite.lending.markets import PositionLifecycle
     from charli3_dendrite.lending.rates import RateModel
 
 # Constructor alternatives of RepaymentMode, LiquidationMode and Option.
@@ -212,12 +216,6 @@ def lendable_principal(pool: FluidV4PoolState) -> int:
     return max(pool.assets["lovelace"] - floor, 0)
 
 
-def _converted(what: str, exc: Exception) -> LendingParseError:
-    if isinstance(exc, LendingParseError):
-        return exc
-    return LendingParseError(f"{what}: {exc}")
-
-
 def pool_to_market(
     pool: FluidV4PoolState,
     pool_manager: FluidV4PoolManagerState | None = None,
@@ -267,7 +265,7 @@ def pool_to_market(
             permissioned=pool.is_permissioned,
         )
     except _CONVERSION_ERRORS as exc:
-        raise _converted(f"pool {pool.out_ref}", exc) from exc
+        raise as_parse_error(f"pool {pool.out_ref}", exc) from exc
 
 
 def _origin(loan: FluidV4LoanState) -> Origin | None:
@@ -303,7 +301,7 @@ def loan_to_position(loan: FluidV4LoanState) -> LendingPosition:
             opened_ms=int(datum.lend_date),  # type: ignore[attr-defined]
         )
     except _CONVERSION_ERRORS as exc:
-        raise _converted(f"loan {loan.out_ref}", exc) from exc
+        raise as_parse_error(f"loan {loan.out_ref}", exc) from exc
 
 
 def request_to_borrow_request(request: FluidV4RequestState) -> BorrowRequest:
@@ -343,7 +341,7 @@ def request_to_borrow_request(request: FluidV4RequestState) -> BorrowRequest:
             != PERMISSIONLESS_MARKER,
         )
     except _CONVERSION_ERRORS as exc:
-        raise _converted(f"request {request.out_ref}", exc) from exc
+        raise as_parse_error(f"request {request.out_ref}", exc) from exc
 
 
 _VIEW_KINDS = (EntityKind.POOL, EntityKind.LOAN, EntityKind.REQUEST)
@@ -353,6 +351,8 @@ class FluidTokensV4MarketSource:
     """FluidTokens V4 pools, loans and requests as common views."""
 
     name = PROTOCOL_NAME
+    # Every V4 loan holds its own identity token, so positions need no chaining.
+    lifecycle: PositionLifecycle | None = None
 
     def __init__(self, config: ConfigDatum | None = None) -> None:
         """Watch the deployment ``config`` names; mainnet by default."""
@@ -369,9 +369,13 @@ class FluidTokensV4MarketSource:
     def parse(
         self,
         info: PoolStateInfo,
+        *,
+        context: ParseContext | None = None,
     ) -> LendingMarket | LendingPosition | BorrowRequest | None:
         """One UTxO as its view; None when it is not a V4 pool, loan or request.
 
+        A V4 view reads only its own UTxO, so ``context`` is ignored.
+
         Raises LendingParseError for a pool, loan or request it cannot convert.
         """
         state = parse_utxo(info, self._selectors)
@@ -394,26 +398,18 @@ class FluidTokensV4MarketSource:
         """
         from charli3_dendrite.lending.fluidtokens_v4.loader import snapshot
 
-        found = snapshot(
-            backend,
-            now_ms=int(time.time() * 1000) if now_ms is None else now_ms,
-        )
+        found = snapshot(backend, now_ms=now_ms)
         managers = {manager.pool_id: manager for manager in found.pool_managers}
         return LendingSnapshot(
-            markets=_convertible(
+            markets=convertible_views(
                 lambda pool: pool_to_market(pool, managers.get(pool.pool_id)),
                 found.pools,
             ),
-            positions=_convertible(loan_to_position, found.loans),
-            requests=_convertible(request_to_borrow_request, found.requests),
+            positions=convertible_views(loan_to_position, found.loans),
+            requests=convertible_views(request_to_borrow_request, found.requests),
         )
 
 
-def _convertible(convert: Any, states: list[Any]) -> tuple[Any, ...]:  # noqa: ANN401
-    out = []
-    for state in states:
-        try:
-            out.append(convert(state))
-        except LendingParseError:
-            continue
-    return tuple(out)
+def market_source() -> FluidTokensV4MarketSource:
+    """The mainnet FluidTokens V4 source, as ``lending.builtins`` registers it."""
+    return FluidTokensV4MarketSource()

{charli3_dendrite-1.6.7.dev0 → charli3_dendrite-1.6.7.dev1}/src/charli3_dendrite/lending/fluidtokens_v4/rates.py

@@ -12,12 +12,9 @@ headline rate annualizes it over the term.
 
 from __future__ import annotations
 
-import dataclasses
 from abc import abstractmethod
 from dataclasses import dataclass
 from fractions import Fraction
-from typing import TYPE_CHECKING
-from typing import Any
 from typing import ClassVar
 
 from charli3_dendrite.lending.fluidtokens.math import amortization_installment
@@ -28,19 +25,17 @@ from charli3_dendrite.lending.fluidtokens.math import perpetual_debt
 from charli3_dendrite.lending.fluidtokens.math import perpetual_outstanding_debt
 from charli3_dendrite.lending.normalized import LendingParseError
 from charli3_dendrite.lending.rates import HOURS_PER_YEAR
+from charli3_dendrite.lending.rates import DataclassIntParams
 from charli3_dendrite.lending.rates import RateKind
 from charli3_dendrite.lending.rates import RateModel
 
-if TYPE_CHECKING:
-    from collections.abc import Mapping
-
 PROTOCOL_NAME = "FluidTokensV4"
 
 _RATE_BASIS = 10_000
 
 
 @dataclass(frozen=True)
-class _FluidRate(RateModel):
+class _FluidRate(DataclassIntParams):
     """Terms every FluidTokens repayment mode carries."""
 
     interest_rate: int
@@ -69,16 +64,6 @@ class _FluidRate(RateModel):
             repayment_time_window=self.repayment_time_window,
         )
 
-    def params(self) -> dict[str, int]:
-        """The datum integers, by field name."""
-        return dataclasses.asdict(self)
-
-    @classmethod
-    def from_params(cls, params: Mapping[str, Any]) -> RateModel:
-        """Rebuild from :meth:`params`."""
-        names = [field.name for field in dataclasses.fields(cls)]
-        return cls(**{name: int(params[name]) for name in names})
-
 
 @dataclass(frozen=True)
 class FluidPerpetualRate(_FluidRate):