charli3_dendrite 1.5.14.dev3__tar.gz → 1.5.15.dev1__tar.gz

{charli3_dendrite-1.5.14.dev3 → charli3_dendrite-1.5.15.dev1}/PKG-INFO

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

{charli3_dendrite-1.5.14.dev3 → charli3_dendrite-1.5.15.dev1}/pyproject.toml

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

{charli3_dendrite-1.5.14.dev3 → charli3_dendrite-1.5.15.dev1}/src/charli3_dendrite/dexs/ob/cardanoswaps.py

@@ -42,6 +42,7 @@ from charli3_dendrite.dexs.ob.ob_base import AbstractOrderState
 from charli3_dendrite.dexs.ob.ob_base import BuyOrderBook
 from charli3_dendrite.dexs.ob.ob_base import OrderBookOrder
 from charli3_dendrite.dexs.ob.ob_base import SellOrderBook
+from charli3_dendrite.dexs.ob.ob_base import fill_within_budget
 from charli3_dendrite.utility import asset_to_value
 
 # v2 one-way beacon minting policy id (also stored verbatim in the datum's
@@ -973,8 +974,7 @@ class CardanoSwapsOrderBook(AbstractOrderBookState):
         for order in book:
             state = order.state
 
-            order_out, _ = state.get_amount_out(in_remaining)
-            order_in, _ = state.get_amount_in(order_out)
+            order_out, order_in = fill_within_budget(state, in_remaining)
 
             # Stop once the remaining budget cannot satisfy a meaningful fill.
             if order_out.quantity() <= 0 or order_in.quantity() <= 0:

{charli3_dendrite-1.5.14.dev3 → charli3_dendrite-1.5.15.dev1}/src/charli3_dendrite/dexs/ob/chadswap.py

@@ -32,6 +32,7 @@ from charli3_dendrite.dexs.ob.ob_base import AbstractOrderState
 from charli3_dendrite.dexs.ob.ob_base import BuyOrderBook
 from charli3_dendrite.dexs.ob.ob_base import OrderBookOrder
 from charli3_dendrite.dexs.ob.ob_base import SellOrderBook
+from charli3_dendrite.dexs.ob.ob_base import fill_within_budget
 from charli3_dendrite.utility import asset_to_value
 
 
@@ -719,8 +720,7 @@ class ChadSwapOrderBook(AbstractOrderBookState):
         for order in book:
             state = order.state
 
-            order_out, _ = state.get_amount_out(in_remaining)
-            order_in, _ = state.get_amount_in(order_out)
+            order_out, order_in = fill_within_budget(state, in_remaining)
 
             # Stop if remaining budget cannot satisfy the smallest meaningful fill.
             if order_out.quantity() <= 0 or order_in.quantity() <= 0:

{charli3_dendrite-1.5.14.dev3 → charli3_dendrite-1.5.15.dev1}/src/charli3_dendrite/dexs/ob/ob_base.py

@@ -242,6 +242,38 @@ class AbstractOrderState(AbstractPairState):
         return values
 
 
+def fill_within_budget(
+    state: AbstractOrderState,
+    budget: Assets,
+    precise: bool = True,
+) -> tuple[Assets, Assets]:
+    """The largest fill of ``state`` whose input fits ``budget``: ``(out, in)``.
+
+    An order prices the output a budget buys and then the input that output costs,
+    each rounded up, so on a partial fill the input can exceed the budget. The output
+    is then shrunk to the largest amount whose input still fits (zero when not even
+    one unit fits).
+    """
+    order_out, _ = state.get_amount_out(budget, precise=precise)
+    order_in, _ = state.get_amount_in(order_out, precise=precise)
+    if order_in.quantity() <= budget.quantity():
+        return order_out, order_in
+    unit = order_out.unit()
+    low, high = 0, order_out.quantity() - 1
+    while low < high:
+        mid = (low + high + 1) // 2
+        need, _ = state.get_amount_in(Assets(**{unit: mid}), precise=precise)
+        if need.quantity() <= budget.quantity():
+            low = mid
+        else:
+            high = mid - 1
+    if low == 0:
+        return Assets(**{unit: 0}), Assets(**{budget.unit(): 0})
+    order_out = Assets(**{unit: low})
+    order_in, _ = state.get_amount_in(order_out, precise=precise)
+    return order_out, order_in
+
+
 class OrderBookOrder(DendriteBaseModel):
     """Represents an order in the order book."""
 

{charli3_dendrite-1.5.14.dev3 → charli3_dendrite-1.5.15.dev1}/src/charli3_dendrite/dexs/ob/saturnswap.py

@@ -40,6 +40,7 @@ from charli3_dendrite.dexs.ob.ob_base import AbstractOrderState
 from charli3_dendrite.dexs.ob.ob_base import BuyOrderBook
 from charli3_dendrite.dexs.ob.ob_base import OrderBookOrder
 from charli3_dendrite.dexs.ob.ob_base import SellOrderBook
+from charli3_dendrite.dexs.ob.ob_base import fill_within_budget
 from charli3_dendrite.utility import asset_to_value
 
 # SaturnSwap charges an on-chain taker fee on every fill that is NOT co-signed by
@@ -1361,8 +1362,11 @@ class SaturnSwapOrderBook(AbstractOrderBookState):
             if state is None:
                 continue
 
-            order_out, _ = state.get_amount_out(in_remaining, precise=precise)
-            order_in, _ = state.get_amount_in(order_out, precise=precise)
+            order_out, order_in = fill_within_budget(
+                state,
+                in_remaining,
+                precise=precise,
+            )
 
             if order_out.quantity() <= 0 or order_in.quantity() <= 0:
                 break
@@ -1451,8 +1455,7 @@ class SaturnSwapOrderBook(AbstractOrderBookState):
             if state is None:
                 continue
 
-            order_out, _ = state.get_amount_out(in_remaining)
-            order_in, _ = state.get_amount_in(order_out)
+            order_out, order_in = fill_within_budget(state, in_remaining)
 
             if order_out.quantity() <= 0 or order_in.quantity() <= 0:
                 break

charli3_dendrite-1.5.15.dev1/src/charli3_dendrite/lending/fluidtokens_v4/__init__.py

@@ -0,0 +1,4 @@
+"""FluidTokens V4 lending protocol integration.
+
+Read side, indexing, and borrower and lender transaction builders.
+"""

{charli3_dendrite-1.5.14.dev3 → charli3_dendrite-1.5.15.dev1}/src/charli3_dendrite/lending/fluidtokens_v4/constants.py

@@ -11,6 +11,10 @@ The lender-manager spend script is not listed in the config datum: pools opt int
 by pointing ``lender_bond_address`` at it, and it ships as a constant here. Its own
 action scripts are listed in the lender-manager config datum, held with a separate
 config NFT.
+
+The pool manager's owner-check scripts are not listed either: they are parameters of
+the pool-manager policy, so they change only with a new pool-manager policy, which
+the config datum would name.
 """
 
 from __future__ import annotations
@@ -69,6 +73,20 @@ LOCKED_BORROWER_MANAGER_SPEND_SKH = (
 # Not carried by the config datum (see the module docstring).
 LENDER_MANAGER_SPEND_SKH = "6743f4b69446b4e066cfb89daa3d01ef041b6d2646968993be4cec09"
 
+# The pool manager's owner checks for a pool edit and a pool cancel: the
+# ``pm_edit_pool`` and ``pm_cancel_pool_manager`` validators of
+# ``ft-cardano-loans-v4`` at ``04b6e70``, applied to the config NFT, the pool spend
+# script, the pool policy and the smart-tokens spend script, and applied in turn to
+# :data:`POOL_MANAGER_POLICY`. That build pairs the i-th spent pool with the i-th
+# spent pool manager by input position; ``a8bb3f4d`` pairs them by NFT and hashes
+# differently.
+POOL_MANAGER_EDIT_POOL_ACTION_SKH = (
+    "df8247f95cf81bf662c38a95f43851022a58f1f0fcbb7b453544afae"
+)
+POOL_MANAGER_CANCEL_ACTION_SKH = (
+    "e39f6aac5e71c42edc7e190456483086dfdd94c73c0e352234cc3d1b"
+)
+
 # Plutus ``Credential``: ``ScriptCredential`` is constructor alternative 1 (tag 122).
 _SCRIPT_CREDENTIAL_TAG = 122
 

charli3_dendrite-1.5.15.dev1/src/charli3_dendrite/lending/fluidtokens_v4/transactions/__init__.py

@@ -0,0 +1 @@
+"""FluidTokens V4 transaction builders: borrower and lender actions."""

{charli3_dendrite-1.5.14.dev3 → charli3_dendrite-1.5.15.dev1}/src/charli3_dendrite/lending/fluidtokens_v4/transactions/borrow.py

@@ -78,6 +78,7 @@ from charli3_dendrite.lending.fluidtokens_v4.transactions.common import ledger_o
 from charli3_dendrite.lending.fluidtokens_v4.transactions.common import loan_address
 from charli3_dendrite.lending.fluidtokens_v4.transactions.common import min_ada
 from charli3_dendrite.lending.fluidtokens_v4.transactions.common import out_ref_of
+from charli3_dendrite.lending.fluidtokens_v4.transactions.common import pool_nft_name
 from charli3_dendrite.lending.fluidtokens_v4.transactions.common import script_hash_of
 from charli3_dendrite.lending.fluidtokens_v4.transactions.common import (
     withdraw_redeemer_position,
@@ -222,14 +223,6 @@ def priced_sides(
     )
 
 
-def pool_nft_name(pool: Utxo) -> bytes:
-    """The name of the one pool NFT a pool UTxO holds."""
-    names = [n for p, n, q in pool.assets if p == c.POOL_POLICY and q == 1]
-    if len(names) != 1:
-        raise ValueError("pool UTxO must hold exactly one pool NFT")
-    return bytes.fromhex(names[0])
-
-
 @dataclass(frozen=True)
 class PoolBorrow:
     """A borrow from one pool: how much, against which collateral option.

{charli3_dendrite-1.5.14.dev3 → charli3_dendrite-1.5.15.dev1}/src/charli3_dendrite/lending/fluidtokens_v4/transactions/builder.py

@@ -1,14 +1,15 @@
 """FluidTokens V4 implementation of the lending transaction seam.
 
 ``resolve_snapshot`` covers a single loan or pool from :class:`ActionParams`; several
-pools or loans in one transaction resolve through the snapshots' ``from_backend``
-directly and go through :meth:`FluidTokensV4TxBuilder.contribute` the same way.
+pools or loans in one transaction, a pool create, and an edit of a pool's terms
+resolve through the snapshots' ``from_backend`` directly and go through
+:meth:`FluidTokensV4TxBuilder.contribute` the same way.
 """
 
 from __future__ import annotations
 
+from collections.abc import Callable
 from typing import TYPE_CHECKING
-from typing import cast
 
 from charli3_dendrite.lending.fluidtokens_v4.datums import PoolDatum
 from charli3_dendrite.lending.fluidtokens_v4.state import collateral_asset_unit
@@ -21,6 +22,25 @@ from charli3_dendrite.lending.fluidtokens_v4.transactions.change_collateral impo
 from charli3_dendrite.lending.fluidtokens_v4.transactions.change_collateral import (
     build_change_collateral,
 )
+from charli3_dendrite.lending.fluidtokens_v4.transactions.pool_cancel import (
+    PoolCancelSnapshot,
+)
+from charli3_dendrite.lending.fluidtokens_v4.transactions.pool_cancel import (
+    build_pool_cancel,
+)
+from charli3_dendrite.lending.fluidtokens_v4.transactions.pool_create import (
+    PoolCreateSnapshot,
+)
+from charli3_dendrite.lending.fluidtokens_v4.transactions.pool_create import (
+    build_pool_create,
+)
+from charli3_dendrite.lending.fluidtokens_v4.transactions.pool_edit import PoolEdit
+from charli3_dendrite.lending.fluidtokens_v4.transactions.pool_edit import (
+    PoolEditSnapshot,
+)
+from charli3_dendrite.lending.fluidtokens_v4.transactions.pool_edit import (
+    build_pool_edit,
+)
 from charli3_dendrite.lending.fluidtokens_v4.transactions.recast import RecastSnapshot
 from charli3_dendrite.lending.fluidtokens_v4.transactions.recast import build_recast
 from charli3_dendrite.lending.fluidtokens_v4.transactions.repay import RepaySnapshot
@@ -36,11 +56,21 @@ if TYPE_CHECKING:
     from charli3_dendrite.lending.transactions.base import ActionParams
     from charli3_dendrite.lending.transactions.snapshot import PoolActionSnapshot
 
-_SNAPSHOT_TYPE: dict[LendingAction, type[PoolActionSnapshot]] = {
-    LendingAction.BORROW: BorrowSnapshot,
-    LendingAction.REPAY: RepaySnapshot,
-    LendingAction.MODIFY_COLLATERAL: ChangeCollateralSnapshot,
-    LendingAction.RECAST: RecastSnapshot,
+# Each action's snapshot type and the function that adds it to a builder.
+_ACTIONS: dict[
+    LendingAction,
+    tuple[type[PoolActionSnapshot], Callable[..., None]],
+] = {
+    LendingAction.BORROW: (BorrowSnapshot, build_borrow),
+    LendingAction.REPAY: (RepaySnapshot, build_repay),
+    LendingAction.MODIFY_COLLATERAL: (
+        ChangeCollateralSnapshot,
+        build_change_collateral,
+    ),
+    LendingAction.RECAST: (RecastSnapshot, build_recast),
+    LendingAction.POOL_CREATE: (PoolCreateSnapshot, build_pool_create),
+    LendingAction.POOL_EDIT: (PoolEditSnapshot, build_pool_edit),
+    LendingAction.POOL_CANCEL: (PoolCancelSnapshot, build_pool_cancel),
 }
 
 
@@ -60,7 +90,7 @@ def _single(collateral: dict[str, int], action: LendingAction) -> tuple[str, int
 
 
 class FluidTokensV4TxBuilder(AbstractLendingTxBuilder):
-    """Build FluidTokens V4 borrow, repay, change-collateral and recast transactions."""
+    """Build FluidTokens V4 borrower and lender transactions."""
 
     @classmethod
     def protocol(cls) -> str:
@@ -69,8 +99,8 @@ class FluidTokensV4TxBuilder(AbstractLendingTxBuilder):
 
     @classmethod
     def supported_actions(cls) -> set[LendingAction]:
-        """Borrow, repay, change collateral and recast."""
-        return set(_SNAPSHOT_TYPE)
+        """Borrow, repay, change collateral, recast, and pool create, edit, cancel."""
+        return set(_ACTIONS)
 
     def resolve_snapshot(
         self,
@@ -93,6 +123,11 @@ class FluidTokensV4TxBuilder(AbstractLendingTxBuilder):
         - MODIFY_COLLATERAL: ``loan_utxo`` is the loan and ``collateral`` its one
           ``{unit: new amount}``; prices are fetched from the registry.
         - RECAST: ``loan_utxo`` is the loan and ``amount`` the principal paid.
+        - POOL_EDIT: ``loan_utxo`` is the pool and ``amount`` the principal it gains
+          (negative withdraws); its terms are kept. ``actor_address`` owns the pool.
+        - POOL_CANCEL: ``loan_utxo`` is the pool; ``actor_address`` owns it.
+        - POOL_CREATE takes lender terms ``ActionParams`` cannot carry: resolve it
+          with ``PoolCreateSnapshot.from_backend``.
         """
         if action == LendingAction.BORROW:
             return self._resolve_borrow(backend, params)
@@ -123,6 +158,33 @@ class FluidTokensV4TxBuilder(AbstractLendingTxBuilder):
                 recasts=[(_out_ref(params.loan_utxo, "loan"), params.amount)],
                 borrower_address=params.actor_address,
             )
+        if action == LendingAction.POOL_EDIT:
+            if not params.amount:
+                raise ValueError(
+                    "POOL_EDIT moves principal: params.amount must be non-zero; edit "
+                    "a pool's terms with PoolEditSnapshot.from_backend",
+                )
+            return PoolEditSnapshot.from_backend(
+                backend,
+                edits=[
+                    PoolEdit(
+                        _out_ref(params.loan_utxo, "pool"),
+                        principal_change=params.amount,
+                    ),
+                ],
+                lender_address=params.actor_address,
+            )
+        if action == LendingAction.POOL_CANCEL:
+            return PoolCancelSnapshot.from_backend(
+                backend,
+                pools=[_out_ref(params.loan_utxo, "pool")],
+                lender_address=params.actor_address,
+            )
+        if action == LendingAction.POOL_CREATE:
+            raise ValueError(
+                "POOL_CREATE needs lender terms ActionParams cannot carry; resolve it "
+                "with PoolCreateSnapshot.from_backend and contribute that snapshot",
+            )
         raise ValueError(f"{self.protocol()} does not support action {action.value!r}")
 
     def _resolve_borrow(
@@ -170,24 +232,14 @@ class FluidTokensV4TxBuilder(AbstractLendingTxBuilder):
         params: ActionParams,  # - the snapshot carries every amount
     ) -> None:
         """Add the action described by ``snapshot`` to ``tx_builder``."""
-        expected = _SNAPSHOT_TYPE.get(action)
-        if expected is None:
+        if action not in _ACTIONS:
             raise ValueError(
                 f"{self.protocol()} does not support action {action.value!r}",
             )
+        expected, build = _ACTIONS[action]
         if not isinstance(snapshot, expected):
             raise TypeError(
                 f"{action.value} expects {expected.__name__}, "
                 f"got {type(snapshot).__name__}",
             )
-        if action == LendingAction.BORROW:
-            build_borrow(tx_builder, snapshot=cast(BorrowSnapshot, snapshot))
-        elif action == LendingAction.REPAY:
-            build_repay(tx_builder, snapshot=cast(RepaySnapshot, snapshot))
-        elif action == LendingAction.MODIFY_COLLATERAL:
-            build_change_collateral(
-                tx_builder,
-                snapshot=cast(ChangeCollateralSnapshot, snapshot),
-            )
-        else:
-            build_recast(tx_builder, snapshot=cast(RecastSnapshot, snapshot))
+        build(tx_builder, snapshot=snapshot)

{charli3_dendrite-1.5.14.dev3 → charli3_dendrite-1.5.15.dev1}/src/charli3_dendrite/lending/fluidtokens_v4/transactions/common.py

@@ -15,13 +15,17 @@ from pycardano import min_lovelace
 from pycardano import plutus_script_hash
 from pycardano import script_hash as pycardano_script_hash
 
+from charli3_dendrite.dataclasses.models import Assets
 from charli3_dendrite.lending.fluidtokens.transactions._common import reward_address
 from charli3_dendrite.lending.fluidtokens.transactions.utxos import Utxo
 from charli3_dendrite.lending.fluidtokens_v4 import constants as c
 from charli3_dendrite.lending.transactions.infra import EvalContext
 from charli3_dendrite.lending.units import constr
+from charli3_dendrite.utility import asset_to_value
 
 if TYPE_CHECKING:
+    from pycardano import Datum
+
     from charli3_dendrite.lending.fluidtokens_v4.datums import CollateralAsset
 
 # Default validity window of a repay or recast. They owe their amount as of the
@@ -48,6 +52,39 @@ def min_ada(output: TransactionOutput) -> int:
     return min_lovelace(EvalContext(last_block_slot=0), output=output)
 
 
+def settled_min_ada(address: Address, assets: dict[str, int], datum: Datum) -> int:
+    """The least ADA an output of ``assets`` and ``datum`` at ``address`` can hold.
+
+    That is the least lovelace amount that covers the min-ADA of the output holding
+    it: the coin's own encoding grows with the amount, so the minimum is iterated to
+    its fixed point. ``assets`` maps unit to quantity and excludes lovelace.
+    """
+    lovelace = 0
+    while True:
+        output = TransactionOutput(
+            address,
+            asset_to_value(Assets(**{"lovelace": lovelace, **assets})),
+            datum=datum,
+        )
+        needed = min_ada(output)
+        if needed <= lovelace:
+            return lovelace
+        lovelace = needed
+
+
+def sole_nft_name(utxo: Utxo, policy: str, what: str) -> bytes:
+    """The name of the one NFT of ``policy`` a ``what`` UTxO holds."""
+    names = [n for p, n, q in utxo.assets if p == policy and q == 1]
+    if len(names) != 1:
+        raise ValueError(f"{what} UTxO must hold exactly one {what} NFT")
+    return bytes.fromhex(names[0])
+
+
+def pool_nft_name(pool: Utxo) -> bytes:
+    """The name of the one pool NFT a pool UTxO holds."""
+    return sole_nft_name(pool, c.POOL_POLICY, "pool")
+
+
 def is_policy_wide(collateral: CollateralAsset) -> bool:
     """True if ``collateral`` names only a policy (any token under it)."""
     return constr(collateral.maybe_asset_name)[0] == _NONE

{charli3_dendrite-1.5.14.dev3 → charli3_dendrite-1.5.15.dev1}/src/charli3_dendrite/lending/fluidtokens_v4/transactions/lender_bond.py

@@ -1,16 +1,17 @@
-"""The lender-bond output datum a V4 borrow must reproduce.
+"""The lender-bond output datum a V4 pool commits to.
 
 A pool commits only ``blake2b_256`` of the lender-bond output's inline datum. Pools
 that send lender bonds to the lender manager commit a :class:`LenderManagerDatum`
 whose fields all come from chain except two lender settings: the pool NFT name, the
 pool's principal asset, the pool manager's owner authorization, and the stake
 credential of the pool's lender-bond address, plus whether liquidations convert the
-collateral to principal and the liquidation fee per mille. The settings are recovered
-by hashing each candidate against the commitment.
+collateral to principal and the liquidation fee per mille. A pool create picks the
+settings; a borrow recovers them by hashing each candidate against the commitment.
 """
 
 from __future__ import annotations
 
+import hashlib
 from collections.abc import Iterator
 
 import cbor2  # type: ignore[import-not-found]
@@ -32,19 +33,23 @@ _FALSE = RawPlutusData(cbor2.CBORTag(121, []))
 # Plutus ``Credential.ScriptCredential`` is constructor alternative 1.
 _SCRIPT_CREDENTIAL = 1
 
-# A liquidation fee is expressed per mille.
-_MAX_FEE_PER_MILLE = 1000
+# A fee per mille is 0 to 1000: the range this module's commitment search covers,
+# and the range a pool create bounds its own fees to.
+MAX_FEE_PER_MILLE = 1000
 
-# The settings every lender-manager pool used when this module was written; tried
-# first so the common case needs a single hash.
-_USUAL_SETTINGS = (_TRUE, 40)
+# The settings every lender-manager pool used when this module was written: a pool
+# create defaults to them, and a borrow tries them first so the common case needs a
+# single hash.
+CONVERT_LIQUIDATIONS = True
+LIQUIDATION_FEE_PER_MILLE = 40
 
 
-def _settings() -> Iterator[tuple[RawPlutusData, int]]:
-    yield _USUAL_SETTINGS
-    for convert in (_TRUE, _FALSE):
-        for fee in range(_MAX_FEE_PER_MILLE + 1):
-            if (convert, fee) != _USUAL_SETTINGS:
+def _settings() -> Iterator[tuple[bool, int]]:
+    usual = (CONVERT_LIQUIDATIONS, LIQUIDATION_FEE_PER_MILLE)
+    yield usual
+    for convert in (True, False):
+        for fee in range(MAX_FEE_PER_MILLE + 1):
+            if (convert, fee) != usual:
                 yield convert, fee
 
 
@@ -73,21 +78,49 @@ def lender_bond_datum(
             "pool sends lender bonds to an address other than the lender manager; "
             "the borrow builder does not support such pools",
         )
-    _, (_payment, staking) = constr(pool_datum.lender_bond_address)
-    stake_credential = RawPlutusData(
-        staking
-        if isinstance(staking, cbor2.CBORTag)
-        else cbor2.loads(staking.to_cbor()),
-    )
     for convert, fee in _settings():
-        candidate = LenderManagerDatum(
-            lender_auth=pool_manager.pool_owner_auth,
-            lender_stake_credential=stake_credential,
-            should_liquidation_convert_to_principal=convert,
-            liquidation_fee_per_mille=fee,
+        candidate = lender_manager_datum(
+            pool_datum,
             pool_id=pool_id,
-            principal_asset=pool_datum.common_data.principal_asset,
+            pool_manager=pool_manager,
+            convert_liquidations=convert,
+            liquidation_fee_per_mille=fee,
         ).to_cbor_hex()
         if lender_bond_datum_matches(pool_datum, candidate):
             return candidate
     raise ValueError("no lender-manager setting reproduces the pool's commitment")
+
+
+def lender_manager_datum(
+    pool_datum: PoolDatum,
+    *,
+    pool_id: bytes,
+    pool_manager: PoolManagerDatum,
+    convert_liquidations: bool,
+    liquidation_fee_per_mille: int,
+) -> LenderManagerDatum:
+    """The lender-manager datum of pool ``pool_id``'s lender bonds.
+
+    The stake credential is the one of the pool's lender-bond address; the principal
+    asset is the pool's.
+    """
+    _, (_payment, staking) = constr(pool_datum.lender_bond_address)
+    return LenderManagerDatum(
+        lender_auth=pool_manager.pool_owner_auth,
+        lender_stake_credential=RawPlutusData(
+            staking
+            if isinstance(staking, cbor2.CBORTag)
+            else cbor2.loads(staking.to_cbor()),
+        ),
+        should_liquidation_convert_to_principal=_TRUE
+        if convert_liquidations
+        else _FALSE,
+        liquidation_fee_per_mille=liquidation_fee_per_mille,
+        pool_id=pool_id,
+        principal_asset=pool_datum.common_data.principal_asset,
+    )
+
+
+def lender_bond_commitment(datum: LenderManagerDatum) -> bytes:
+    """What a pool commits to: ``blake2b_256`` of the lender-bond datum."""
+    return hashlib.blake2b(datum.to_cbor(), digest_size=32).digest()

{charli3_dendrite-1.5.14.dev3 → charli3_dendrite-1.5.15.dev1}/src/charli3_dendrite/lending/fluidtokens_v4/transactions/loan_action.py

@@ -49,6 +49,7 @@ from charli3_dendrite.lending.fluidtokens_v4.transactions.common import (
 from charli3_dendrite.lending.fluidtokens_v4.transactions.common import min_ada
 from charli3_dendrite.lending.fluidtokens_v4.transactions.common import out_ref_of
 from charli3_dendrite.lending.fluidtokens_v4.transactions.common import script_hash_of
+from charli3_dendrite.lending.fluidtokens_v4.transactions.common import sole_nft_name
 from charli3_dendrite.lending.fluidtokens_v4.transactions.common import (
     withdraw_redeemer_position,
 )
@@ -78,10 +79,7 @@ _BOOL_TRUE = 1
 
 def loan_nft_name(loan: Utxo) -> bytes:
     """The name of the one loan NFT a loan UTxO holds."""
-    names = [n for p, n, q in loan.assets if p == c.LOAN_POLICY and q == 1]
-    if len(names) != 1:
-        raise ValueError("loan UTxO must hold exactly one loan NFT")
-    return bytes.fromhex(names[0])
+    return sole_nft_name(loan, c.LOAN_POLICY, "loan")
 
 
 @dataclass