charli3_dendrite 1.4.16.dev0__tar.gz → 1.4.17.dev0__tar.gz

{charli3_dendrite-1.4.16.dev0 → charli3_dendrite-1.4.17.dev0}/PKG-INFO

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

{charli3_dendrite-1.4.16.dev0 → charli3_dendrite-1.4.17.dev0}/pyproject.toml

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

charli3_dendrite-1.4.17.dev0/src/charli3_dendrite/lending/__init__.py

@@ -0,0 +1,40 @@
+"""Read-only lending-protocol analytics (pools, loans, oracles).
+
+Importing this package registers all oracle resolvers. Lending classes are
+intentionally NOT exported from `charli3_dendrite/__init__.py` and do not
+subclass DEX bases, so they never enter DEX discovery.
+"""
+
+from charli3_dendrite.lending.base import AbstractLendingPoolState
+from charli3_dendrite.lending.base import AbstractLoanState
+from charli3_dendrite.lending.base import LendingBook
+from charli3_dendrite.lending.base import LendingPriceBook
+from charli3_dendrite.lending.oracles.charli3 import Charli3Resolver
+from charli3_dendrite.lending.oracles.dex_pooled import DexPooledResolver
+from charli3_dendrite.lending.oracles.fluid import FluidResolver
+from charli3_dendrite.lending.oracles.models import OraclePrice
+from charli3_dendrite.lending.oracles.models import OracleRef
+from charli3_dendrite.lending.oracles.models import OracleSource
+from charli3_dendrite.lending.oracles.models import PriceMap
+from charli3_dendrite.lending.oracles.models import register_resolver
+from charli3_dendrite.lending.oracles.orcfax import OrcfaxResolver
+from charli3_dendrite.lending.oracles.qtoken import QTokenResolver
+
+register_resolver(Charli3Resolver())
+register_resolver(OrcfaxResolver())
+register_resolver(QTokenResolver())
+register_resolver(DexPooledResolver())
+register_resolver(FluidResolver(OracleSource.FLUID_AGGREGATED))
+register_resolver(FluidResolver(OracleSource.FLUID_POOLED))
+register_resolver(FluidResolver(OracleSource.FLUID_DEDICATED))
+
+__all__ = [
+    "AbstractLendingPoolState",
+    "AbstractLoanState",
+    "LendingBook",
+    "LendingPriceBook",
+    "OraclePrice",
+    "OracleRef",
+    "OracleSource",
+    "PriceMap",
+]

charli3_dendrite-1.4.17.dev0/src/charli3_dendrite/lending/base.py

@@ -0,0 +1,369 @@
+"""Read-only lending pool/loan state bases + aggregation views."""
+
+from __future__ import annotations
+
+from abc import ABC
+from abc import abstractmethod
+from collections.abc import Sequence
+from decimal import Decimal
+from typing import TYPE_CHECKING
+
+from pycardano import Address
+from pycardano import PlutusData
+from pycardano import PlutusV1Script
+from pycardano import PlutusV2Script
+from pycardano import UTxO
+
+from charli3_dendrite.dataclasses.models import Assets
+from charli3_dendrite.dataclasses.models import DendriteBaseModel
+from charli3_dendrite.dataclasses.models import PoolSelector
+from charli3_dendrite.dataclasses.models import PoolStateInfo
+from charli3_dendrite.dataclasses.models import PoolStateList
+from charli3_dendrite.lending.oracles.models import OracleRef
+from charli3_dendrite.lending.oracles.models import OracleSource
+from charli3_dendrite.lending.oracles.models import PriceMap
+from charli3_dendrite.lending.oracles.models import get_resolver
+
+if TYPE_CHECKING:
+    from charli3_dendrite.backend.backend_base import AbstractBackend
+
+
+class AbstractLendingPoolState(DendriteBaseModel, ABC):
+    """Snapshot of a lending pool/market (read-only)."""
+
+    assets: Assets
+    block_time: int
+    block_index: int
+    plutus_v2: bool
+    datum_cbor: str
+    datum_hash: str
+    tx_index: int
+    tx_hash: str
+    inactive: bool = False
+
+    _pool_datum_parsed: PlutusData | None = None
+
+    @classmethod
+    @abstractmethod
+    def protocol(cls) -> str:
+        """Official protocol name (e.g. 'Danogo', 'FluidTokens')."""
+        raise NotImplementedError
+
+    @classmethod
+    def pool_policy(cls) -> list[str] | None:
+        """Pool-NFT policy (or policy+name) used to recognize the pool."""
+        return None
+
+    @classmethod
+    @abstractmethod
+    def pool_datum_class(cls) -> type[PlutusData]:
+        """Plutus type for the pool datum."""
+        raise NotImplementedError
+
+    @classmethod
+    def oracle_datum_class(cls) -> type[PlutusData] | None:
+        """Optional protocol-owned oracle datum type."""
+        return None
+
+    @classmethod
+    @abstractmethod
+    def pool_selector(cls) -> PoolSelector:
+        """UTxO selector for this pool/market."""
+        raise NotImplementedError
+
+    @classmethod
+    def reference_utxo(cls) -> UTxO | None:
+        """Optional protocol reference-script UTxO."""
+        return None
+
+    @classmethod
+    def default_script_class(cls) -> type[PlutusV1Script | PlutusV2Script]:
+        """Default Plutus script version for this protocol."""
+        return PlutusV1Script
+
+    def script_class(self) -> type[PlutusV1Script | PlutusV2Script]:
+        """Plutus script version implied by this UTxO."""
+        return PlutusV2Script if self.plutus_v2 else PlutusV1Script
+
+    @property
+    @abstractmethod
+    def stake_address(self) -> Address:
+        """Stake address controlling this pool."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def pool_id(self) -> str:
+        """Stable identifier for this pool/market."""
+        raise NotImplementedError
+
+    @property
+    def pool_datum(self) -> PlutusData:
+        """Parsed pool datum (lazily decoded from CBOR)."""
+        if self._pool_datum_parsed is None:
+            self._pool_datum_parsed = self.pool_datum_class().from_cbor(self.datum_cbor)
+        return self._pool_datum_parsed
+
+    @property
+    @abstractmethod
+    def borrowable_unit(self) -> str:
+        """Unit that can be borrowed from this pool."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def utilization_ratio(self) -> Decimal:
+        """Fraction of supplied liquidity currently borrowed."""
+        raise NotImplementedError
+
+    def oracle_refs(self) -> list[OracleRef]:
+        """Oracle feeds this pool needs (e.g. alt-token rates). Default none."""
+        return []
+
+    @abstractmethod
+    def max_borrow_for_collateral_value(self, collateral_value_lovelace: int) -> int:
+        """Best-effort quote: collateral value -> borrowable size."""
+        raise NotImplementedError
+
+
+class AbstractLoanState(DendriteBaseModel, ABC):
+    """Snapshot of a single borrower position (read-only)."""
+
+    assets: Assets
+    block_time: int
+    block_index: int
+    plutus_v2: bool
+    datum_cbor: str
+    datum_hash: str
+    tx_index: int
+    tx_hash: str
+    inactive: bool = False
+
+    _loan_datum_parsed: PlutusData | None = None
+
+    @classmethod
+    @abstractmethod
+    def protocol(cls) -> str:
+        """Official protocol name (e.g. 'Danogo', 'FluidTokens')."""
+        raise NotImplementedError
+
+    @classmethod
+    def protocol_nft_policy(cls) -> list[str] | None:
+        """Policy / policy+name prefixes for the loan-identity NFT."""
+        return None
+
+    @classmethod
+    @abstractmethod
+    def loan_datum_class(cls) -> type[PlutusData]:
+        """Plutus type for the loan datum."""
+        raise NotImplementedError
+
+    @classmethod
+    def oracle_datum_class(cls) -> type[PlutusData] | None:
+        """Optional protocol-owned oracle datum type."""
+        return None
+
+    @classmethod
+    @abstractmethod
+    def loan_selector(cls) -> PoolSelector:
+        """UTxO selector for loans (same shape as pool_selector)."""
+        raise NotImplementedError
+
+    @classmethod
+    def reference_utxo(cls) -> UTxO | None:
+        """Optional protocol reference-script UTxO."""
+        return None
+
+    @classmethod
+    def default_script_class(cls) -> type[PlutusV1Script | PlutusV2Script]:
+        """Default Plutus script version for this protocol."""
+        return PlutusV1Script
+
+    def script_class(self) -> type[PlutusV1Script | PlutusV2Script]:
+        """Plutus script version implied by this UTxO."""
+        return PlutusV2Script if self.plutus_v2 else PlutusV1Script
+
+    @property
+    @abstractmethod
+    def stake_address(self) -> Address:
+        """Stake address controlling this loan."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def loan_id(self) -> str:
+        """Stable identifier for this loan."""
+        raise NotImplementedError
+
+    @property
+    @abstractmethod
+    def pool_id(self) -> str:
+        """Identifier of the pool/market this loan belongs to."""
+        raise NotImplementedError
+
+    @property
+    def loan_datum(self) -> PlutusData:
+        """Parsed loan datum (lazily decoded from CBOR)."""
+        if self._loan_datum_parsed is None:
+            self._loan_datum_parsed = self.loan_datum_class().from_cbor(self.datum_cbor)
+        return self._loan_datum_parsed
+
+    @property
+    @abstractmethod
+    def borrowed_unit(self) -> str:
+        """Unit borrowed by this loan."""
+        raise NotImplementedError
+
+    def oracle_refs(self) -> list[OracleRef]:
+        """Oracle feeds needed to value this loan. Default none (fixed-ratio)."""
+        return []
+
+    @abstractmethod
+    def current_debt(self) -> int:
+        """Principal + accrued interest, in smallest units of borrowed asset."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def collateral_value_lovelace(self, prices: PriceMap) -> int:
+        """Collateral value in lovelace at the given prices."""
+        raise NotImplementedError
+
+    @abstractmethod
+    def health_factor(self, prices: PriceMap) -> Decimal:
+        """Liquidation ratio; default rule liquidatable when <= 1."""
+        raise NotImplementedError
+
+    def is_liquidatable(self, prices: PriceMap) -> bool:
+        """Default: health_factor <= 1. Override if on-chain rule differs."""
+        return self.health_factor(prices) <= 1
+
+    def repay_amount_for_target_hf(self, target_hf: Decimal, prices: PriceMap) -> int:
+        """Repayment to reach `target_hf`.
+
+        Generic helper assuming the borrowed asset is denominated in lovelace
+        (i.e. collateral_value_lovelace and debt share units). Protocols whose
+        borrowed asset is not ADA should override.
+        """
+        if target_hf <= 0:
+            return self.current_debt()
+        debt = Decimal(self.current_debt())
+        max_safe_debt = Decimal(self.collateral_value_lovelace(prices)) / target_hf
+        if debt <= max_safe_debt:
+            return 0
+        return int((debt - max_safe_debt).to_integral_value(rounding="ROUND_CEILING"))
+
+
+class LendingPriceBook:
+    """Batch oracle resolution for a set of loans/pools.
+
+    Selectors are de-duplicated within each source group, so each unique feed
+    is fetched once (one fetch per unique selector per source) no matter how
+    many loans reference it.
+    """
+
+    @staticmethod
+    def build(
+        items: Sequence[AbstractLoanState | AbstractLendingPoolState],
+        *,
+        backend: AbstractBackend,
+        at_ms: int | None = None,  # noqa: ARG004
+    ) -> PriceMap:
+        """Resolve every source referenced by `items` into one `PriceMap`."""
+        refs: list[OracleRef] = []
+        for item in items:
+            refs.extend(item.oracle_refs())
+
+        by_source: dict[OracleSource, list[OracleRef]] = {}
+        for ref in refs:
+            by_source.setdefault(ref.source, []).append(ref)
+
+        price_map = PriceMap()
+        for source, group in by_source.items():
+            resolver = get_resolver(source)
+            seen: set[tuple] = set()
+            infos: list[PoolStateInfo] = []
+            for selector in resolver.selectors(group):
+                key = (
+                    tuple(sorted(selector.addresses)),
+                    tuple(sorted(selector.assets or ())),
+                )
+                if key in seen:
+                    continue
+                seen.add(key)
+                infos.extend(list(backend.get_pool_utxos(**selector.model_dump())))
+            utxos = PoolStateList(root=infos)
+            for ref in group:
+                price = resolver.resolve(ref, utxos)
+                if price is not None:
+                    price_map.add(price)
+        return price_map
+
+
+class LendingBook:
+    """Aggregated, price-aware view of loans for bots and risk analytics."""
+
+    def __init__(
+        self,
+        loans_full: list[AbstractLoanState],
+        *,
+        block_time: int,
+        prices: PriceMap | None = None,
+        pool: AbstractLendingPoolState | None = None,
+    ) -> None:
+        """Store loans plus optional prices/pool context for aggregation."""
+        self.loans_full = list(loans_full)
+        self.block_time = block_time
+        self.prices = prices or PriceMap()
+        self.pool = pool
+
+    @classmethod
+    def from_loans(
+        cls,
+        loans: Sequence[AbstractLoanState],
+        *,
+        prices: PriceMap | None = None,
+        pool: AbstractLendingPoolState | None = None,
+        block_time: int | None = None,
+    ) -> LendingBook:
+        """Construct a book from `loans`, defaulting `block_time` to the latest."""
+        bt = (
+            block_time
+            if block_time is not None
+            else max((ln.block_time for ln in loans), default=0)
+        )
+        return cls(list(loans), block_time=bt, prices=prices, pool=pool)
+
+    def active_loans(self) -> list[AbstractLoanState]:
+        """Loans that are not marked inactive."""
+        return [ln for ln in self.loans_full if not ln.inactive]
+
+    def liquidatable_loans(self) -> list[AbstractLoanState]:
+        """Active loans whose health factor makes them liquidatable."""
+        return [ln for ln in self.active_loans() if ln.is_liquidatable(self.prices)]
+
+    def liquidation_candidates_by_urgency(self) -> list[AbstractLoanState]:
+        """Liquidatable loans sorted by ascending health factor."""
+        scored = [
+            (ln, ln.health_factor(self.prices)) for ln in self.liquidatable_loans()
+        ]
+        scored.sort(key=lambda item: (item[1], item[0].loan_id))
+        return [ln for ln, _ in scored]
+
+    def near_liquidation(
+        self,
+        buffer: Decimal = Decimal("0.05"),
+    ) -> list[AbstractLoanState]:
+        """Healthy active loans within `buffer` above the liquidation threshold."""
+        hi = Decimal(1) + buffer
+        scored = [
+            (ln, ln.health_factor(self.prices))
+            for ln in self.active_loans()
+            if not ln.is_liquidatable(self.prices)
+        ]
+        scored = [(ln, hf) for ln, hf in scored if hf <= hi]
+        scored.sort(key=lambda item: (item[1], item[0].loan_id))
+        return [ln for ln, _ in scored]
+
+    def by_pool(self, pool_id: str) -> list[AbstractLoanState]:
+        """Active loans belonging to `pool_id`."""
+        return [ln for ln in self.active_loans() if ln.pool_id == pool_id]

charli3_dendrite-1.4.17.dev0/src/charli3_dendrite/lending/danogo/__init__.py

@@ -0,0 +1,21 @@
+"""Read-only Danogo Float-Rate Lending analytics.
+
+Importing this module registers the Danogo aggregator resolver. Danogo classes do not
+subclass DEX bases and are not exported from `charli3_dendrite/__init__.py`.
+"""
+
+from charli3_dendrite.lending.danogo.loader import build_book
+from charli3_dendrite.lending.danogo.market import DanogoMarket
+from charli3_dendrite.lending.danogo.oracles.aggregator import DanogoAggregatorResolver
+from charli3_dendrite.lending.danogo.state import DanogoLoanState
+from charli3_dendrite.lending.danogo.state import DanogoPoolState
+from charli3_dendrite.lending.oracles.models import register_resolver
+
+register_resolver(DanogoAggregatorResolver())
+
+__all__ = [
+    "DanogoLoanState",
+    "DanogoMarket",
+    "DanogoPoolState",
+    "build_book",
+]

charli3_dendrite-1.4.17.dev0/src/charli3_dendrite/lending/danogo/constants.py

@@ -0,0 +1,157 @@
+"""Danogo deployment anchors + on-chain address resolution.
+
+Anchors are None until supplied. With an anchor, `resolve_addresses` reads the Protocol
+Config UTxO's ProtocolDatum and derives the four script addresses.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+from typing import TypedDict
+
+from pycardano import Address
+from pycardano import Network
+from pycardano import ScriptHash
+
+from charli3_dendrite.lending.danogo.datums import ProtocolDatum
+from charli3_dendrite.lending.danogo.oracles.locator import LeafHandle
+
+if TYPE_CHECKING:
+    from charli3_dendrite.backend.backend_base import AbstractBackend
+
+# Deployment anchors (Cardano mainnet). NFT anchors are policy(56 hex)+asset_name(hex);
+# the path anchor is policy-only. The Oracle Global Config NFT and the Oracle Path FTs
+# share a single minting policy.
+PROTOCOL_CONFIG_NFT: str | None = (
+    "bc2d3b7cf1009c788b1daf2208a38026ab20d7f8209d896ad1a09c14"
+    "e567b64450c406a17f869eb4e430f2e2a6c74d103edb988cb1bc1347de285c69"
+)
+ORACLE_GLOBAL_CONFIG_NFT: str | None = (
+    "bd23e2977937bb6054f625e5b566e28e294dcd8f7e8d0d33979ed90c"
+    "1e5e4d7ac0ba99f5f4b3d3c7764054ccce87ef497407785a4ee04d2beadb0b78"
+)
+ORACLE_PATH_FT_POLICY: str | None = (
+    "bd23e2977937bb6054f625e5b566e28e294dcd8f7e8d0d33979ed90c"
+)
+
+# Per-supply-token oracle routing anchor. Each supply token's price config is anchored
+# to one Danogo reference pool: the `OraclePathDatum.anchor` (28 bytes) is the terminal
+# bridge that converts every collateral price into the supply token. Many path-config
+# UTxOs (across older config versions and other supply tokens) share the path FT policy;
+# the create-loan oracle Withdraw validator only accepts the path datum anchored to the
+# borrowed market's supply token. Keyed by supply-token unit ("lovelace" for ADA).
+ORACLE_QUOTE_ANCHOR: dict[str, str] = {
+    "lovelace": "836cc68931c2e4e3e838602eca1902591d216837bafddfe6f0c8cb07",
+    # USDM-supply market routing anchor.
+    "c48cbb3d5e57ed56e276bc45f99ab39abe94e6cd7ac39fb402da47ad0014df105553444d": (
+        "64e648e02d76567652d55e33106123f72ceac04bf3dcaf4f70737d58"
+    ),
+    # DjedMicroUSD-supply market routing anchor.
+    (
+        "8db269c3ec630e06ae29f74bc39edd1f87c819f1056206e879a1cd61"
+        "446a65644d6963726f555344"
+    ): "504791c3a0348e8ebadac99d5df8753b1b12e3849b8bd69653e5db92",
+    # USDC-supply market routing anchor.
+    (
+        "1f3aec8bfe7ea4fe14c5f121e2a92e301afe414147860d557cac7e34" "5553444378"
+    ): "853fca625371e99f0e0b94663f3513dd99ec141bac5dad8128b41db6",
+    # USDA-supply market routing anchor.
+    (
+        "fe7c786ab321f41c654ef6c1af7b3250a613c24e4213e0425a7ae456" "55534441"
+    ): "a8fe3b72f0195c5af7a9df18402ba5ec77938f5795da7bb738653c9d",
+}
+
+# Minswap V2 LP minting policy. The oracle path config encodes a Minswap LP source as
+# the LP token *name* (32 bytes) under this policy; matching a borrowed collateral's
+# resolved Minswap LP leaf to a path config's sources confirms the config prices it.
+MINSWAP_LP_POLICY: str = "f5808c2c990d86da54bfc97d89cee6efa20cd8461616359478d96b4c"
+
+# Curated cross-check oracle feeds per cross-quote supply token (keyed by supply-token
+# unit). A cross-quote market's ``ada -> quote`` conversion is deviation-checked by the
+# routing path config against independent external price feeds that the mined pricing
+# recipes never reference (no recipe step names them), so the recipe-driven leaf
+# resolution does not fetch them. The oracle ``Withdraw`` still walks them, so a
+# fully-live cross-quote build must additionally fetch these feed UTxOs; the compose
+# filter then references only the candidate whose rate is within the path config's
+# deviation tolerance. Each handle is resolved through the same single-UTxO
+# discriminator the recipe leaves use. Only cross-quote supply tokens (those with a
+# canonical ``ada -> quote`` recipe) appear here; ADA-quote / single-hop markets need
+# none.
+CROSS_CHECK_SUPPLEMENTAL_HANDLES: dict[str, tuple[LeafHandle, ...]] = {
+    # USDCx-supply market: Indigo iUSD ``ada -> quote`` feed (a singleton UTxO pinned
+    # by its feed NFT at a stable script address), parsed as ``OracleUtxoType.TINDIGO``.
+    "1f3aec8bfe7ea4fe14c5f121e2a92e301afe414147860d557cac7e345553444378": (
+        LeafHandle(
+            otype="TINDIGO",
+            address="addr1wygyy4mdrh5kxsmm6ja4phxez3vh2mngz2muqmw4gw3n9jqdu67a0",
+            nft_policy="e3455f2715338b454fb853442f72dc03b98396854f97510027fe22ff",
+            nft_name="695553443230323231313138313935393036",
+        ),
+    ),
+}
+
+# Script credentials that hold the config/oracle reference UTxOs. Backends match
+# UTxOs by payment credential and don't support NFT-only lookups, so resolution
+# starts from these addresses: PROTOCOL_CONFIG_SKH holds the Protocol Config UTxO,
+# and ORACLE_DATA_SKH holds the Oracle Global Config UTxO and the Oracle Path FTs.
+PROTOCOL_CONFIG_SKH: str | None = (
+    "9a0054cf2ab678edcd7528d16a388e5b1cefa3af40d5b9634ab96de6"
+)
+ORACLE_DATA_SKH: str | None = "79a5116ee2ff13ffd53b2615568574fc804740a07bc2ff8930d2d6fb"
+
+
+class DanogoScriptAddresses(TypedDict):
+    """The four Danogo script addresses derived from the ProtocolDatum."""
+
+    pool: str
+    loan: str
+    config_pool: str
+    oracle: str
+
+
+def _addr(skh_hex: str) -> str:
+    # Returns a payment-credential (enterprise, no-stake) script *identity*. On-chain
+    # pool/loan UTxOs may sit at base addresses with a stake part, so callers must match
+    # by payment credential, not raw address-string equality (some backends match raw
+    # address strings).
+    return Address(
+        payment_part=ScriptHash(bytes.fromhex(skh_hex)),
+        network=Network.MAINNET,
+    ).encode()
+
+
+def resolve_addresses(
+    backend: AbstractBackend,
+    *,
+    config_nft: str | None = None,
+    config_address: str | None = None,
+) -> DanogoScriptAddresses:
+    """Read ProtocolDatum at the Protocol Config UTxO; return the 4 script addresses.
+
+    Backends match UTxOs by payment credential and don't support NFT-only lookups, so
+    resolution needs the address that holds the Protocol Config NFT. It defaults to
+    `PROTOCOL_CONFIG_SKH`; pass `config_address` to point at another deployment.
+    """
+    nft = config_nft or PROTOCOL_CONFIG_NFT
+    if nft is None:
+        raise ValueError("PROTOCOL_CONFIG_NFT anchor not set")
+    if config_address is None and PROTOCOL_CONFIG_SKH is not None:
+        config_address = _addr(PROTOCOL_CONFIG_SKH)
+    addresses = [config_address] if config_address else []
+    rows = list(
+        backend.get_pool_utxos(
+            addresses=addresses,
+            assets=[nft],
+            limit=1,
+            historical=False,
+        ),
+    )
+    if not rows:
+        raise ValueError("Protocol Config UTxO not found for anchor")
+    d = ProtocolDatum.from_cbor(rows[0].datum_cbor)
+    return DanogoScriptAddresses(
+        pool=_addr(d.pool_skh.hex()),
+        loan=_addr(d.loan_skh.hex()),
+        config_pool=_addr(d.config_pool_skh.hex()),
+        oracle=_addr(d.oracle_skh.hex()),
+    )