charli3_dendrite 1.6.6.dev0__tar.gz → 1.6.7.dev0__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "charli3_dendrite"
-version = "1.6.6-dev0"
+version = "1.6.7-dev0"
 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.6-dev0"
+current_version = "1.6.7-dev0"
 parse = """(?x)
     (?P<major>\\d+)\\.
     (?P<minor>\\d+)\\.

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

@@ -10,8 +10,6 @@ from dataclasses import dataclass
 from fractions import Fraction
 from typing import TYPE_CHECKING
 
-from charli3_dendrite.lending.danogo.oracles.leaves import liqwid_oracle_feed_id
-from charli3_dendrite.lending.danogo.oracles.leaves import parse_liqwid_oracle_v2
 from charli3_dendrite.lending.danogo.oracles.leaves import parse_minswap_lp
 from charli3_dendrite.lending.danogo.oracles.locator import LeafHandle
 from charli3_dendrite.lending.danogo.oracles.locator import Recipe
@@ -19,6 +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.oracles.models import OraclePrice
 from charli3_dendrite.lending.oracles.models import OracleSource
 from charli3_dendrite.lending.oracles.models import PriceMap
@@ -57,9 +57,9 @@ 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 -> ``feed_id:priced_asset``. Neither part is unique on its own
-      (one feed id spans many assets; one asset, e.g. ADA, can have several feeds), but
-      together they pin the UTxO.
+    * 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.
     * 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

{charli3_dendrite-1.6.6.dev0 → charli3_dendrite-1.6.7.dev0}/src/charli3_dendrite/lending/danogo/oracles/leaves.py

@@ -9,7 +9,6 @@ Verified bit-exact against on-chain ``OraclePriceCalcRdmr`` prices (tx
 929a7d68...de8237 and 590d...e6a069):
 * ``danogo_pool_dtoken_rate`` (``TDANOGO_POOL``).
 * ``parse_danogo_staking_rate`` (``TDANOGO_STAKING``).
-* ``parse_liqwid_oracle_v2`` (``TLIQWID_ORACLE_V2``) -- reproduces ADA = 16271/100000.
 * ``parse_minswap_lp`` + ``cpamm_price_from_reserves`` (``TMINSWAP_LP``) -- the
   STRIKE/ADA hop of a 3-hop derived price.
 * ``parse_djed`` (``TDJED``) -- pair rate decoded.
@@ -22,9 +21,9 @@ Value parsers landed; bit-exact end-to-end check pending the ``price_path`` deco
 (these source types only ever appear as intermediate hops on-chain, never as a
 standalone collateral price):
 * ``parse_indigo`` (``TINDIGO``) -- iAsset->ADA, 1e6 scale.
-* ``parse_liqwid_market_state`` (``TLIQWID_MARKET_STATE``) -- qToken exchange rate;
-  reproduces the on-chain qToken price as ``rate/100/ada_usd`` for the one market
-  that appears on-chain.
+
+The Liqwid leaves (``TLIQWID_ORACLE_V2``, ``TLIQWID_MARKET_STATE`` and
+``TLIQWID_MARKET_PARAM``) are parsed by ``charli3_dendrite.lending.liqwid.datums``.
 
 Every ``OracleUtxoType`` observed in full mainnet history (9 of the 17 registry
 entries) now has a parser, including ``TLIQWID_MARKET_PARAM`` (a config record, not a
@@ -37,12 +36,21 @@ from __future__ import annotations
 
 import cbor2  # type: ignore[import-not-found]
 
-from charli3_dendrite.lending.danogo.datums import asset_unit
+# Kept for compatibility: the Liqwid parsers live in
+# ``charli3_dendrite.lending.liqwid.datums``. These re-exports will be removed in a
+# later minor release.
+from charli3_dendrite.lending.liqwid.datums import liqwid_oracle_feed_id  # noqa: F401
+from charli3_dendrite.lending.liqwid.datums import liqwid_qtoken_rate  # noqa: F401
+from charli3_dendrite.lending.liqwid.datums import (  # noqa: F401
+    parse_liqwid_market_param,
+)
+from charli3_dendrite.lending.liqwid.datums import (  # noqa: F401
+    parse_liqwid_market_state,
+)
+from charli3_dendrite.lending.liqwid.datums import parse_liqwid_oracle_v2  # noqa: F401
+from charli3_dendrite.lending.units import plutus_fields
+from charli3_dendrite.lending.units import tuple_asset_unit
 
-# Liqwid Oracle V2 datum field order: [feed_id, Constr1[[asset]], [num, denom],
-# timestamp_ms, validity_ms, config].
-_LIQWID_ASSET_FIELD = 1
-_LIQWID_PRICE_FIELD = 2
 # Minswap V2 pool datum field order: [stake, asset_a, asset_b, total_liquidity,
 # reserve_a, reserve_b, fee_a, fee_b, ...].
 _MS_ASSET_A_FIELD = 1
@@ -59,27 +67,6 @@ _SPLASH_ASSET_X_FIELD = 1
 _SPLASH_ASSET_Y_FIELD = 2
 _SPLASH_LP_FIELD = 3
 _SPLASH_MAX_LP = (1 << 63) - 1
-# Liqwid market-state datum: the qToken<->underlying exchange rate is the rational at
-# index 9 of the 11-field state record.
-_LIQWID_MARKET_RATE_FIELD = 9
-# Liqwid market-parameter (config) datum: interest-model + risk fields. Only a couple
-# carry unambiguous values; the leaf is not a price source.
-_LIQWID_PARAM_BASE_RATE_FIELD = 0
-_LIQWID_PARAM_COLLATERAL_RATIO_FIELD = 12
-
-
-def _fields(obj: object) -> list:
-    """Positional fields of a CBOR Constr (or a bare list) as a Python list."""
-    inner = obj.value if isinstance(obj, cbor2.CBORTag) else obj
-    return list(inner)
-
-
-def _tuple_asset_unit(arr: object) -> str:
-    """Dendrite unit string from a ``[policy, name]`` value (Constr-wrapped or bare)."""
-    seq = _fields(arr)
-    policy = seq[0] if len(seq) > 0 and isinstance(seq[0], bytes) else b""
-    name = seq[1] if len(seq) > 1 and isinstance(seq[1], bytes) else b""
-    return asset_unit(policy, name)
 
 
 def cpamm_price_from_reserves(
@@ -133,7 +120,7 @@ def parse_danogo_staking_rate(datum: str | bytes) -> tuple[int, int]:
     Raises ValueError on non-positive supply.
     """
     raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
-    fields = _fields(cbor2.loads(raw))
+    fields = plutus_fields(cbor2.loads(raw))
     total, circulating = int(fields[0]), int(fields[1])
     if total <= 0 or circulating <= 0:
         raise ValueError("non-positive staking supply")
@@ -154,47 +141,13 @@ def parse_indigo(datum: str | bytes) -> tuple[int, int]:
     Raises ValueError on a non-positive price.
     """
     raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
-    inner = _fields(_fields(cbor2.loads(raw))[0])
+    inner = plutus_fields(plutus_fields(cbor2.loads(raw))[0])
     price = int(inner[0])
     if price <= 0:
         raise ValueError("non-positive indigo price")
     return (price, _INDIGO_SCALE)
 
 
-def parse_liqwid_oracle_v2(datum: str | bytes) -> tuple[str, tuple[int, int]]:
-    """Liqwid Oracle V2 leaf -> (priced_asset_unit, (num, denom)).
-
-    Datum is a 6-field record ``[feed_id, Constr1[[asset]], [num, denom], ts, validity,
-    config]``; the rate is the priced asset in the configured quote. Verified: ADA
-    (the empty TupleAsset) at (16271, 100000) on tx 929a7d68...de8237 leaf
-    ``(REF, TLIQWID_ORACLE_V2, 0)``.
-
-    Raises ValueError on a non-positive denominator.
-    """
-    raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
-    fields = _fields(cbor2.loads(raw))
-    asset_unit_str = _tuple_asset_unit(_fields(fields[_LIQWID_ASSET_FIELD])[0])
-    price = _fields(fields[_LIQWID_PRICE_FIELD])
-    num, denom = int(price[0]), int(price[1])
-    if denom <= 0:
-        raise ValueError("non-positive liqwid oracle denom")
-    return asset_unit_str, (num, denom)
-
-
-def liqwid_oracle_feed_id(datum: str | bytes) -> str:
-    """Liqwid Oracle V2 feed identifier (datum field 0) as hex.
-
-    Several Liqwid feeds can price the same asset (e.g. two ADA feeds) and share one
-    marker token at a common address, so the asset alone does not pin a UTxO; the
-    field-0 feed id does and is stable across price updates. Empty string if absent.
-    """
-    raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
-    feed = _fields(cbor2.loads(raw))[0]
-    if isinstance(feed, (bytes, bytearray)):
-        return feed.hex()
-    return str(feed)
-
-
 def parse_orcfax_fs(datum: str | bytes) -> tuple[str, tuple[int, int]]:
     """Orcfax Feed Status leaf -> (feed_name, (num, denom)).
 
@@ -207,8 +160,8 @@ def parse_orcfax_fs(datum: str | bytes) -> tuple[str, tuple[int, int]]:
     Raises ValueError on a non-positive denominator.
     """
     raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
-    body = _fields(_fields(cbor2.loads(raw))[0])
-    price = _fields(body[2])
+    body = plutus_fields(plutus_fields(cbor2.loads(raw))[0])
+    price = plutus_fields(body[2])
     num, denom = int(price[0]), int(price[1])
     if denom <= 0:
         raise ValueError("non-positive orcfax denom")
@@ -227,8 +180,8 @@ def parse_djed(datum: str | bytes) -> tuple[str, tuple[int, int]]:
     Raises ValueError on a non-positive denominator.
     """
     raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
-    inner = _fields(_fields(cbor2.loads(raw))[1])
-    price = _fields(inner[0])
+    inner = plutus_fields(plutus_fields(cbor2.loads(raw))[1])
+    price = plutus_fields(inner[0])
     num, denom = int(price[0]), int(price[1])
     pair = inner[2]
     label = pair.decode() if isinstance(pair, bytes) else str(pair)
@@ -248,11 +201,11 @@ def parse_minswap_lp(datum: str | bytes) -> tuple[str, int, str, int]:
     feed the STRIKE->ADA hop of a 3-hop derived price.
     """
     raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
-    fields = _fields(cbor2.loads(raw))
+    fields = plutus_fields(cbor2.loads(raw))
     return (
-        _tuple_asset_unit(fields[_MS_ASSET_A_FIELD]),
+        tuple_asset_unit(fields[_MS_ASSET_A_FIELD]),
         int(fields[_MS_RESERVE_A_FIELD]),
-        _tuple_asset_unit(fields[_MS_ASSET_B_FIELD]),
+        tuple_asset_unit(fields[_MS_ASSET_B_FIELD]),
         int(fields[_MS_RESERVE_B_FIELD]),
     )
 
@@ -265,11 +218,11 @@ def parse_splash_cpamm_g3(datum: str | bytes) -> tuple[str, str, str]:
     quote-side reserve and the LP balance. See ``splash_lp_token_price``.
     """
     raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
-    fields = _fields(cbor2.loads(raw))
+    fields = plutus_fields(cbor2.loads(raw))
     return (
-        _tuple_asset_unit(fields[_SPLASH_ASSET_X_FIELD]),
-        _tuple_asset_unit(fields[_SPLASH_ASSET_Y_FIELD]),
-        _tuple_asset_unit(fields[_SPLASH_LP_FIELD]),
+        tuple_asset_unit(fields[_SPLASH_ASSET_X_FIELD]),
+        tuple_asset_unit(fields[_SPLASH_ASSET_Y_FIELD]),
+        tuple_asset_unit(fields[_SPLASH_LP_FIELD]),
     )
 
 
@@ -297,60 +250,3 @@ def splash_lp_token_price(
     if circulating_lp <= 0 or reserve_quote <= 0:
         raise ValueError("non-positive circulating LP or reserve")
     return (2 * reserve_quote, circulating_lp)
-
-
-def parse_liqwid_market_state(datum: str | bytes) -> tuple[int, int]:
-    """Liqwid market-state leaf -> qToken<->underlying exchange rate (state field 9).
-
-    The 11-field state record carries the exchange rate as the rational at index 9
-    (underlying per qToken). Returns (num, denom).
-
-    Verified for the one Liqwid market that appears on-chain: with the rate
-    360073866973321/12033383669199582 the qToken collateral price reproduces exactly
-    as ``rate / 100 / ada_usd`` (tx 578fae97...), where the ``/100`` is the
-    underlying's price and ``ada_usd`` the Liqwid ADA oracle. The two extra factors
-    are separate path hops, not part of this leaf. All 8 on-chain occurrences are the
-    same market, so the index-9 location is confirmed but not yet cross-checked
-    against a second market.
-
-    Raises ValueError on a non-positive rate.
-    """
-    raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
-    rate = _fields(cbor2.loads(raw))[_LIQWID_MARKET_RATE_FIELD]
-    num, denom = int(rate[0]), int(rate[1])
-    if num <= 0 or denom <= 0:
-        raise ValueError("non-positive liqwid market exchange rate")
-    return (num, denom)
-
-
-def parse_liqwid_market_param(
-    datum: str | bytes,
-) -> tuple[tuple[int, int], tuple[int, int]]:
-    """Liqwid market-parameter (config) leaf -> (base_rate, collateral_ratio).
-
-    This leaf is NOT a price source: it carries the market's interest-rate model and
-    risk parameters (the Danogo oracle takes the qToken exchange rate from the
-    market-*state* leaf, never from here). Only the two unambiguously-typed rationals
-    are surfaced -- the per-block base rate at field 0 and the collateral ratio at
-    field 12 -- both as (num, denom); the remaining 30+ fields are left raw. Decoded
-    for completeness so the source type is no longer an unparsed gap, and for future
-    borrow-APY / health-factor work.
-
-    On-chain config (tx daf74541...): base_rate=1/50, collateral_ratio=8696/10000.
-    """
-    raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
-    fields = _fields(cbor2.loads(raw))
-    base = fields[_LIQWID_PARAM_BASE_RATE_FIELD]
-    coll = fields[_LIQWID_PARAM_COLLATERAL_RATIO_FIELD]
-    return ((int(base[0]), int(base[1])), (int(coll[0]), int(coll[1])))
-
-
-def liqwid_qtoken_rate(
-    *,
-    qtoken_rate_num: int,
-    qtoken_rate_denom: int,
-) -> tuple[int, int]:
-    """QToken -> underlying rate as (num, denom). Raises on non-positive denom/num."""
-    if qtoken_rate_num <= 0 or qtoken_rate_denom <= 0:
-        raise ValueError("non-positive qtoken rate")
-    return (qtoken_rate_num, qtoken_rate_denom)

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

@@ -43,12 +43,12 @@ from charli3_dendrite.lending.danogo.oracles.leaves import danogo_pool_dtoken_ra
 from charli3_dendrite.lending.danogo.oracles.leaves import parse_danogo_staking_rate
 from charli3_dendrite.lending.danogo.oracles.leaves import parse_djed
 from charli3_dendrite.lending.danogo.oracles.leaves import parse_indigo
-from charli3_dendrite.lending.danogo.oracles.leaves import parse_liqwid_market_state
-from charli3_dendrite.lending.danogo.oracles.leaves import parse_liqwid_oracle_v2
 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 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

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

@@ -49,7 +49,6 @@ 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 replay_recipe
-from charli3_dendrite.lending.danogo.oracles.leaves import parse_liqwid_market_state
 from charli3_dendrite.lending.danogo.oracles.leaves import parse_orcfax_fs
 from charli3_dendrite.lending.danogo.oracles.locator import Recipe
 from charli3_dendrite.lending.danogo.oracles.locator import load_registry
@@ -77,6 +76,7 @@ from charli3_dendrite.lending.danogo.transactions.context import TopupWithdrawSn
 from charli3_dendrite.lending.danogo.transactions.oracle_synth import (
     synthesize_oracle_redeemer,
 )
+from charli3_dendrite.lending.liqwid.datums import parse_liqwid_market_state
 from charli3_dendrite.lending.math import floor_div
 from charli3_dendrite.lending.transactions.infra import OUTPUT_MIN_ADA
 from charli3_dendrite.lending.transactions.infra import PLACEHOLDER_FEE

charli3_dendrite-1.6.7.dev0/src/charli3_dendrite/lending/liqwid/__init__.py

@@ -0,0 +1 @@
+"""Liqwid Finance on-chain datum parsers."""

charli3_dendrite-1.6.7.dev0/src/charli3_dendrite/lending/liqwid/datums.py

@@ -0,0 +1,112 @@
+"""Liqwid Finance datum parsers.
+
+Pure decoders for the Liqwid on-chain records that are read as price and rate
+sources: the Oracle V2 price feed, the market state (qToken exchange rate), and the
+market parameters (risk configuration). Each parser takes the datum as CBOR hex or
+raw bytes.
+"""
+
+from __future__ import annotations
+
+import cbor2  # type: ignore[import-not-found]
+
+from charli3_dendrite.lending.units import plutus_fields
+from charli3_dendrite.lending.units import tuple_asset_unit
+
+# Liqwid Oracle V2 datum field order: [updater_key, Constr1[[asset]], [num, denom],
+# timestamp_ms, validity_ms, config].
+_LIQWID_ASSET_FIELD = 1
+_LIQWID_PRICE_FIELD = 2
+# Liqwid market-state datum: the qToken<->underlying exchange rate is the rational at
+# index 9 of the 11-field state record.
+_LIQWID_MARKET_RATE_FIELD = 9
+# Liqwid market-parameter (config) datum: the initial qToken exchange rate at field 0
+# and the maximum loan-to-value on weighted collateral at field 12.
+_LIQWID_PARAM_INITIAL_QTOKEN_RATE_FIELD = 0
+_LIQWID_PARAM_MAX_LTV_FIELD = 12
+
+
+def parse_liqwid_oracle_v2(datum: str | bytes) -> tuple[str, tuple[int, int]]:
+    """Liqwid Oracle V2 datum -> (priced_asset_unit, (num, denom)).
+
+    Datum is a 6-field record ``[updater_key, Constr1[[asset]], [num, denom], ts,
+    validity, config]``; the rate is the priced asset (field 1) in the feed's
+    configured quote. ADA (the empty TupleAsset) is ``"lovelace"``.
+
+    Raises ValueError on a non-positive denominator.
+    """
+    raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
+    fields = plutus_fields(cbor2.loads(raw))
+    asset_unit_str = tuple_asset_unit(plutus_fields(fields[_LIQWID_ASSET_FIELD])[0])
+    price = plutus_fields(fields[_LIQWID_PRICE_FIELD])
+    num, denom = int(price[0]), int(price[1])
+    if denom <= 0:
+        raise ValueError("non-positive liqwid oracle denom")
+    return asset_unit_str, (num, denom)
+
+
+def liqwid_oracle_feed_id(datum: str | bytes) -> str:
+    """Liqwid Oracle V2 datum field 0 -- the oracle updater's key -- as hex.
+
+    The updater key is shared by every feed that updater publishes, so it does not
+    identify a feed on its own. Nor does the oracle token plus the priced asset
+    (field 1, see ``parse_liqwid_oracle_v2``): one oracle token can carry more than
+    one feed for the same asset. The updater key together with the priced asset
+    distinguishes the feeds that share an oracle token. A field 0 that is not a
+    bytestring is returned as its ``str``.
+    """
+    raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
+    feed = plutus_fields(cbor2.loads(raw))[0]
+    if isinstance(feed, (bytes, bytearray)):
+        return feed.hex()
+    return str(feed)
+
+
+def parse_liqwid_market_state(datum: str | bytes) -> tuple[int, int]:
+    """Liqwid market-state datum -> qToken exchange rate (state field 9).
+
+    Field 9 of the 11-field state record is the qToken exchange rate (underlying per
+    qToken), a rational. Returns (num, denom).
+
+    Raises ValueError on a non-positive rate.
+    """
+    raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
+    rate = plutus_fields(cbor2.loads(raw))[_LIQWID_MARKET_RATE_FIELD]
+    num, denom = int(rate[0]), int(rate[1])
+    if num <= 0 or denom <= 0:
+        raise ValueError("non-positive liqwid market exchange rate")
+    return (num, denom)
+
+
+def parse_liqwid_market_param(
+    datum: str | bytes,
+) -> tuple[tuple[int, int], tuple[int, int]]:
+    """Liqwid market-parameter (config) datum -> (initial_qtoken_rate, max_ltv).
+
+    This datum is the market's interest-model and risk configuration, not a price
+    source (the live qToken exchange rate is read from the market-state datum, see
+    ``parse_liqwid_market_state``). Two rationals are surfaced, both as (num, denom):
+
+    * field 0, the initial qToken exchange rate (underlying per qToken) a new market
+      starts from, e.g. 1/50;
+    * field 12, the maximum loan-to-value on weighted collateral; the protocol's
+      minimum health factor is its reciprocal.
+
+    The remaining fields are left raw.
+    """
+    raw = bytes.fromhex(datum) if isinstance(datum, str) else datum
+    fields = plutus_fields(cbor2.loads(raw))
+    initial = fields[_LIQWID_PARAM_INITIAL_QTOKEN_RATE_FIELD]
+    max_ltv = fields[_LIQWID_PARAM_MAX_LTV_FIELD]
+    return ((int(initial[0]), int(initial[1])), (int(max_ltv[0]), int(max_ltv[1])))
+
+
+def liqwid_qtoken_rate(
+    *,
+    qtoken_rate_num: int,
+    qtoken_rate_denom: int,
+) -> tuple[int, int]:
+    """QToken -> underlying rate as (num, denom). Raises on non-positive denom/num."""
+    if qtoken_rate_num <= 0 or qtoken_rate_denom <= 0:
+        raise ValueError("non-positive qtoken rate")
+    return (qtoken_rate_num, qtoken_rate_denom)

{charli3_dendrite-1.6.6.dev0 → charli3_dendrite-1.6.7.dev0}/src/charli3_dendrite/lending/units.py

@@ -25,6 +25,26 @@ def asset_unit(policy: bytes, name: bytes) -> str:
     return policy.hex() + name.hex()
 
 
+def plutus_fields(obj: object) -> list:
+    """Positional fields of a compact-form CBOR Constr (or a bare list) as a list.
+
+    Any ``cbor2.CBORTag`` is unwrapped without checking its tag, so this suits the
+    compact constructor tags (121-127, 1280+) and bare lists. A general-form
+    constructor (tag 102) wraps ``[alt, fields]`` and would come back as that pair;
+    use ``constr`` for it.
+    """
+    inner = obj.value if isinstance(obj, cbor2.CBORTag) else obj
+    return list(inner)
+
+
+def tuple_asset_unit(arr: object) -> str:
+    """Dendrite unit string from a ``[policy, name]`` value (Constr-wrapped or bare)."""
+    seq = plutus_fields(arr)
+    policy = seq[0] if len(seq) > 0 and isinstance(seq[0], bytes) else b""
+    name = seq[1] if len(seq) > 1 and isinstance(seq[1], bytes) else b""
+    return asset_unit(policy, name)
+
+
 def script_payment_address(script_hash_hex: str) -> str:
     """Mainnet enterprise address whose payment credential is ``script_hash_hex``.