charli3_dendrite 1.5.8.dev0__tar.gz → 1.5.9.dev0__tar.gz

{charli3_dendrite-1.5.8.dev0 → charli3_dendrite-1.5.9.dev0}/PKG-INFO

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

{charli3_dendrite-1.5.8.dev0 → charli3_dendrite-1.5.9.dev0}/pyproject.toml

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

{charli3_dendrite-1.5.8.dev0 → charli3_dendrite-1.5.9.dev0}/src/charli3_dendrite/dexs/amm/dano.py

@@ -35,8 +35,10 @@ from pycardano import TransactionId
 from pycardano import TransactionInput
 from pycardano import TransactionOutput
 from pycardano import UTxO
+from pycardano import Value
 from pycardano import Withdrawals
 from pycardano import plutus_script_hash
+from pycardano.serialization import ByteString
 from pycardano.serialization import CBORSerializable
 
 from charli3_dendrite.backend import get_backend
@@ -204,19 +206,44 @@ def parse_swap_redeemer_bytes(
     return first_byte, action, entries
 
 
+def _value_to_assets(value: Value) -> Assets:
+    """Convert a pycardano ``Value`` (a raw on-chain UTxO amount) to ``Assets``.
+
+    Used to seed the new pool output from the spent pool UTxO's exact value bag
+    so the swap only mutates the traded reserves + swap-fee lovelace, leaving the
+    pool's min-ADA, dex NFT, and any other assets untouched (the withdraw
+    validator requires the continuation to preserve them).
+    """
+    assets = Assets(root={"lovelace": int(value.coin)})
+    multi = getattr(value, "multi_asset", None)
+    if multi:
+        for policy, names in multi.data.items():
+            for asset_name, quantity in names.data.items():
+                unit = policy.payload.hex() + asset_name.payload.hex()
+                assets.root[unit] = int(quantity)
+    return assets
+
+
 @dataclass
 class DanoSwapRedeemer(CBORSerializable):
-    """Single-pool Dano swap redeemer (Spend or Withdraw).
-
-    The on-chain redeemer Plutus Data is the raw swap payload serialized as a
-    CBOR *byte string* (``0x58<len><payload>``); :meth:`to_primitive` returns
-    the payload so it serializes that way. The pool input index and the first
-    byte (``pool_in_idx`` for Spend, the protocol-config reference index for
-    Withdraw) depend on the FINAL transaction ordering, so they are resolved
-    post-build by :meth:`set_idx`, which the tx builder calls after sorting and
-    indexing inputs (mirrors ``SSPoolRedeemer.set_idx`` and the clmm-sdk's
-    ``RedeemerArg`` callback). ``pool_out_idx`` is the pool's position in the
-    swap's batch vector — ``0`` for a single-pool swap — NOT a tx output index.
+    """Dano swap redeemer (Spend or Withdraw) for a batch of >= 1 pool spends.
+
+    A Dano swap tx spends N >= 1 pool UTxOs governed by a single withdraw-zero:
+    the tx carries N Spend redeemers + one Withdraw redeemer, and EVERY redeemer
+    carries the same batch vector of per-pool ``(pool_in_idx, pool_out_idx,
+    delta)`` entries. Only the leading ``first_byte`` differs — a Spend's is its
+    own pool input index; the Withdraw's is the protocol-config reference index.
+    ``pool_in_idx`` is the pool's transaction input index; ``pool_out_idx`` is the
+    pool's position in the batch vector (its append index ``0..N-1``), NOT a tx
+    output index. The input index depends on the FINAL sorted inputs, so the
+    batch is resolved post-build by :meth:`set_idx`, which the tx builder calls
+    after sorting and indexing inputs (mirrors ``SSPoolRedeemer.set_idx`` and the
+    clmm-sdk's ``RedeemerArg`` callback).
+
+    ``swap_utxo`` accumulates the batch on ``tx_builder._dano_swap_batch`` as each
+    pool is folded in, so a single-pool call and a composed multi-pool tx share
+    one code path. The on-chain redeemer Plutus Data is the raw swap payload
+    serialized as a CBOR byte string; :meth:`to_primitive` returns the payload.
     """
 
     pool_input: TransactionInput
@@ -240,8 +267,32 @@ class DanoSwapRedeemer(CBORSerializable):
                 return i
         raise InvalidPoolError("redeemer UTxO not found in transaction during set_idx")
 
+    def _resolve_entries(
+        self,
+        tx_builder: TransactionBuilder,
+    ) -> list[tuple[int, int, int]]:
+        """Resolve the shared batch entry vector in pool-batch order.
+
+        Every Spend and the single Withdraw redeemer of a Dano tx carry the same
+        vector of ``(pool_in_idx, pool_out_idx, delta)`` entries — one per pool
+        folded into ``tx_builder._dano_swap_batch`` (append order). Mirrors the
+        clmm-sdk ``swapTokensRedeemer``: ``pool_in_idx`` is the pool's transaction
+        input index; ``pool_out_idx`` is the pool's position in the batch vector
+        (its append index ``0..N-1``), NOT a tx output index; ``delta`` is that
+        pool's signed swap amount. Order is the batch append order (no sort).
+        """
+        batch = getattr(tx_builder, "_dano_swap_batch", None)
+        if not batch:
+            batch = [(self.pool_input, self.delta_amount)]
+        inputs = list(tx_builder.inputs)
+        return [
+            (self._sorted_index(inputs, pool_input), pool_out_idx, delta)
+            for pool_out_idx, (pool_input, delta) in enumerate(batch)
+        ]
+
     def set_idx(self, tx_builder: TransactionBuilder) -> None:
-        """Resolve pool/config indices from the final (sorted) transaction."""
+        """Resolve the shared batch + this redeemer's first byte post-build."""
+        self._entries = self._resolve_entries(tx_builder)
         self.pool_in_idx = self._sorted_index(list(tx_builder.inputs), self.pool_input)
         if self.is_withdraw:
             if self.protocol_config_input is None:
@@ -255,13 +306,22 @@ class DanoSwapRedeemer(CBORSerializable):
         else:
             self.first_byte = self.pool_in_idx
 
-    def to_primitive(self) -> bytes:
-        """Serialize the redeemer as the packed swap payload bytestring."""
-        return build_swap_redeemer_bytes(
-            delta_amount=self.delta_amount,
-            pool_in_idx=self.pool_in_idx,
-            pool_out_idx=self.pool_out_idx,
-            first_byte=self.first_byte,
+    def to_primitive(self) -> ByteString:
+        """Serialize the redeemer as the packed batch swap payload bytestring.
+
+        Wrapped in :class:`ByteString` so a payload longer than 64 bytes (any
+        batch of >= 2 pools: 2 + 34*N bytes) serializes as a CBOR
+        indefinite-length chunked bytestring, as the on-chain validator requires;
+        a single-pool payload (36 bytes) stays a definite bytestring.
+        """
+        entries = getattr(self, "_entries", None)
+        if entries is None:
+            entries = [(self.pool_in_idx, self.pool_out_idx, self.delta_amount)]
+        return ByteString(
+            build_batch_swap_redeemer_bytes(
+                first_byte=self.first_byte,
+                entries=entries,
+            ),
         )
 
     @classmethod
@@ -732,15 +792,20 @@ class DanoCLMMState(AbstractConstantLiquidityPoolState):
 
     def _new_pool_assets(
         self,
+        base_assets: Assets,
         pool_change_x: int,
         pool_change_y: int,
         swap_fee: int,
         staking_reward: int = 0,
     ) -> Assets:
         d = self._datum
-        # Build the new output from the GROSS bag — the on-chain UTxO must keep
-        # the platform fees + min-ADA that ``assets`` (net) no longer carries.
-        new = self._gross_assets()
+        # Copy the spent pool UTxO's exact value bag and mutate ONLY the traded
+        # reserves + swap-fee lovelace. The pool's min-ADA, dex NFT, and any other
+        # assets carry over untouched — the withdraw validator requires the
+        # continuation to preserve them, and reconstructing from the net reserves
+        # (``_gross_assets``) drops a token/token pool's real ADA (its min-ADA is
+        # not a reserve, so ``assets`` never carried it).
+        new = Assets(root=dict(base_assets.root))
         if self.dex_nft is not None:
             new.root[self.dex_nft.unit()] = 1
         new.root[d.unit_x] = new.root.get(d.unit_x, 0) + pool_change_x
@@ -834,6 +899,22 @@ class DanoCLMMState(AbstractConstantLiquidityPoolState):
             raise InvalidPoolError("Could not re-fetch pool UTxO address via backend")
         pool_address = order_info[0].address
 
+        # Seed the input value + new pool output from the pool UTxO's EXACT
+        # on-chain value bag (min-ADA, dex NFT, any stray assets included) so the
+        # swap mutates only the traded reserves + swap-fee lovelace. Reconstructing
+        # from the net reserves (``_gross_assets``) drops a token/token pool's real
+        # ADA — its min-ADA is not a reserve, so ``assets`` never carried it — and
+        # the withdraw validator then rejects the continuation for not preserving
+        # it (mirrors SaturnSwap reading its input's coin). Resolve the raw UTxO by
+        # out-ref via the chain context; fall back to the reconstructed gross bag
+        # when a context cannot resolve by out-ref.
+        pool_bag = pool_in_assets
+        resolve_utxo = getattr(tx_builder.context, "utxo_by_tx_id", None)
+        if resolve_utxo is not None:
+            raw_utxo = resolve_utxo(self.tx_hash, self.tx_index)
+            if raw_utxo is not None:
+                pool_bag = _value_to_assets(raw_utxo.output.amount)
+
         # Overdue ADA pool: when curEpoch > last_withdraw_epoch the validator
         # requires the pool's accrued staking rewards to be withdrawn from the
         # per-pool stake credential in the SAME tx (a second withdrawal) and the
@@ -884,6 +965,7 @@ class DanoCLMMState(AbstractConstantLiquidityPoolState):
 
         new_datum = self.compute_new_datum(delta_amount, swap_fee, cur_epoch)
         new_pool_assets = self._new_pool_assets(
+            pool_bag,
             pool_change_x,
             pool_change_y,
             swap_fee,
@@ -897,7 +979,7 @@ class DanoCLMMState(AbstractConstantLiquidityPoolState):
             ),
             output=TransactionOutput(
                 address=Address.decode(pool_address),
-                amount=asset_to_value(pool_in_assets),
+                amount=asset_to_value(pool_bag),
                 datum=self._datum,
             ),
         )
@@ -914,42 +996,54 @@ class DanoCLMMState(AbstractConstantLiquidityPoolState):
                 "Pool script reference UTxO unavailable from backend",
             )
 
-        # The spend + withdraw redeemers encode the pool input index and the
-        # first byte (pool input index for Spend, protocol-config reference
-        # index for Withdraw), which depend on the FINAL sorted inputs /
-        # reference inputs. The builder may still trim or reorder inputs after
-        # this call, so the indices are resolved POST-BUILD by
-        # ``DanoSwapRedeemer.set_idx`` — the tx builder runs it after assigning
-        # redeemer indices (mirrors Splash's pool redeemer + the clmm-sdk's
-        # ``RedeemerArg`` callback). ``pool_out_idx`` is the single-pool batch
-        # position (0), not a tx output index.
+        # Fold this pool into the tx's shared Dano swap batch. A Dano tx spends
+        # N >= 1 pool UTxOs under ONE withdraw-zero: every Spend redeemer and the
+        # single Withdraw redeemer carry the same batch vector, resolved
+        # POST-BUILD in ``DanoSwapRedeemer.set_idx`` (the builder runs it after
+        # assigning redeemer indices). Composing another Dano pool into the same
+        # ``tx_builder`` appends here and reuses the existing withdraw-zero — the
+        # first pool folded in owns it, later pools only extend the batch.
+        batch = getattr(tx_builder, "_dano_swap_batch", None)
+        if batch is None:
+            batch = []
+            tx_builder._dano_swap_batch = batch
+        first_dano = len(batch) == 0
+        batch.append((input_utxo.input, delta_amount))
+
         spend_redeemer = DanoSwapRedeemer(
             pool_input=input_utxo.input,
             delta_amount=delta_amount,
             is_withdraw=False,
         )
-        withdraw_redeemer = DanoSwapRedeemer(
-            pool_input=input_utxo.input,
-            delta_amount=delta_amount,
-            is_withdraw=True,
-            protocol_config_input=pc_utxo.input,
-        )
-
         tx_builder.add_script_input(
             utxo=input_utxo,
             script=script_ref,
             redeemer=Redeemer(spend_redeemer),
         )
 
+        # Add the withdraw-zero (and its batch Withdraw redeemer) exactly once per
+        # tx. Merge into any existing withdrawals rather than overwrite, so a
+        # prior Dano pool's withdraw-zero and any overdue per-pool staking
+        # withdrawal survive.
         reward_addr = Address.from_primitive(DANO_POOL_REWARD_ADDRESS_MAINNET)
-        withdrawals: dict[bytes, int] = {bytes(reward_addr): 0}
+        withdrawals: dict[bytes, int] = (
+            dict(tx_builder.withdrawals) if tx_builder.withdrawals else {}
+        )
+        withdrawals[bytes(reward_addr)] = 0
         if is_overdue and staking_reward_addr is not None:
             withdrawals[bytes(staking_reward_addr)] = reward
         tx_builder.withdrawals = Withdrawals(withdrawals)
-        tx_builder.add_withdrawal_script(
-            script_ref,
-            Redeemer(withdraw_redeemer),
-        )
+        if first_dano:
+            withdraw_redeemer = DanoSwapRedeemer(
+                pool_input=input_utxo.input,
+                delta_amount=delta_amount,
+                is_withdraw=True,
+                protocol_config_input=pc_utxo.input,
+            )
+            tx_builder.add_withdrawal_script(
+                script_ref,
+                Redeemer(withdraw_redeemer),
+            )
         if is_overdue and staking_ref_utxo is not None:
             # Per-pool staking-reward withdrawal. Its redeemer is pool-input
             # indexed (like Spend, NOT the protocol-config-indexed withdraw-zero).

{charli3_dendrite-1.5.8.dev0 → charli3_dendrite-1.5.9.dev0}/src/charli3_dendrite/lending/danogo/loader.py

@@ -28,7 +28,10 @@ from charli3_dendrite.lending.danogo.state import DanogoLoanState
 from charli3_dendrite.lending.danogo.state import DanogoPoolState
 
 if TYPE_CHECKING:
+    from collections.abc import Collection
+
     from charli3_dendrite.backend.backend_base import AbstractBackend
+    from charli3_dendrite.dataclasses.models import Assets
     from charli3_dendrite.dataclasses.models import PoolStateInfo
     from charli3_dendrite.lending.oracles.models import PriceMap
 
@@ -103,6 +106,29 @@ def _pool_nft_name(info: PoolStateInfo, policy: str) -> str | None:
     return None
 
 
+def _loan_market_name(
+    assets: Assets,
+    loan_policy: str,
+    valid_names: Collection[str],
+) -> str | None:
+    """Pool-NFT name (hex) of the market a loan belongs to, from its loan-identity NFT.
+
+    Each loan UTxO carries a loan token minted under the loan script hash whose asset
+    name IS the pool-NFT name of the loan's market (`create_loan` mints it that way).
+    Mirroring `_pool_nft_name`, this reads that name directly off the loan rather than
+    guessing the market from the borrowed supply token (several markets can share a
+    supply token) or the collateral (several markets can accept the same collateral).
+    Returns the name only when it is a known market/pool name (in `valid_names`), else
+    None (the loan is skipped, matching the existing skip-on-parse-failure degrade).
+    """
+    for unit, qty in assets.root.items():
+        if unit != "lovelace" and unit.startswith(loan_policy) and qty == 1:
+            name = unit[len(loan_policy) :]
+            if name in valid_names:
+                return name
+    return None
+
+
 def fetch_markets(
     backend: AbstractBackend,
     addresses: DanogoScriptAddresses,
@@ -193,9 +219,22 @@ def snapshot(
     if prices is None:
         try:
             from charli3_dendrite.lending.danogo.oracles import forward
+            from charli3_dendrite.lending.danogo.oracles.locator import (
+                augment_registry_with_bond_dtokens,
+            )
             from charli3_dendrite.lending.danogo.oracles.locator import load_registry
 
             registry = load_registry()
+            # Bond dTokens (a pool's own redeemable dToken) are accepted as collateral
+            # but are not mined for every (dToken, quote); synthesize their pricing
+            # recipes from the live pool/market state before resolving, so a dToken
+            # collateral prices instead of collapsing the loan's health factor.
+            augment_registry_with_bond_dtokens(
+                registry,
+                pool_address=addresses["pool"],
+                config_pool_cred=_payment_cred_hex(addresses["config_pool"]),
+                markets=markets,
+            )
             pairs = {
                 (collateral, market.supply_token)
                 for market in markets.values()
@@ -205,28 +244,26 @@ def snapshot(
         except Exception:  # noqa: BLE001 - pricing outage must not crash the snapshot
             prices = PriceMap()
 
-    # Pair pool <-> market (same pool-NFT name) and index pools by supply token so
-    # loans (which only know their borrowed token) can find their market/pool.
+    # Pair pool <-> market (same pool-NFT name) and index BY THAT NAME. Each loan is
+    # stitched to the market its own loan-identity NFT names -- not one guessed from its
+    # borrowed supply token or collateral, both of which several markets can share.
     pools: list[DanogoPoolState] = []
-    by_supply: dict[str, tuple[DanogoPoolState, DanogoMarket]] = {}
+    by_name: dict[str, tuple[DanogoPoolState, DanogoMarket]] = {}
     for name, pool in pools_by_name.items():
         market = markets.get(name)
         if market is None:
             continue
         pool.attach_market(market)
         pools.append(pool)
-        by_supply[market.supply_token] = (pool, market)
+        by_name[name] = (pool, market)
 
+    loan_policy = _payment_cred_hex(addresses["loan"])
     stitched: list[DanogoLoanState] = []
     for loan in loans:
-        try:
-            supply = loan.borrowed_unit
-        except (ValueError, IndexError, TypeError, AttributeError):
-            continue
-        ctx = by_supply.get(supply)
-        if ctx is None:
+        loan_market = _loan_market_name(loan.assets, loan_policy, by_name)
+        if loan_market is None:
             continue
-        pool, market = ctx
+        pool, market = by_name[loan_market]
         loan.attach_context(pool=pool, market=market, now_ms=now_ms)
         stitched.append(loan)
 

{charli3_dendrite-1.5.8.dev0 → charli3_dendrite-1.5.9.dev0}/src/charli3_dendrite/lending/danogo/oracles/forward.py

@@ -296,10 +296,6 @@ def resolve_prices(
     Emits ``OraclePrice(token=..., quote=quote, ...)``. A pair with no recipe, a
     missing leaf, or a non-reproducing walk is simply omitted (collateral stays unpriced
     -> not-liquidatable). Never raises into the caller.
-
-    NOTE: ``PriceMap`` keys by token only, so a collateral used across markets with
-    different supply tokens can hold only one quote. That's a pre-existing PriceMap
-    constraint, not handled here.
     """
     pm = PriceMap()
     for collateral, quote in pairs: