charli3_dendrite 1.5.15.dev1__tar.gz → 1.5.16.dev0__tar.gz

{charli3_dendrite-1.5.15.dev1 → charli3_dendrite-1.5.16.dev0}/PKG-INFO

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

{charli3_dendrite-1.5.15.dev1 → charli3_dendrite-1.5.16.dev0}/pyproject.toml

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

{charli3_dendrite-1.5.15.dev1 → charli3_dendrite-1.5.16.dev0}/src/charli3_dendrite/lending/fluidtokens_v4/constants.py

@@ -8,9 +8,9 @@ policy id and script hash. The constants below are the live mainnet values:
 follows a config update.
 
 The lender-manager spend script is not listed in the config datum: pools opt into it
-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.
+by pointing ``lender_bond_address`` at it, and it ships as a constant here, as does
+its dispatch withdraw script, a parameter of the spend script. 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
@@ -72,6 +72,9 @@ LOCKED_BORROWER_MANAGER_SPEND_SKH = (
 
 # Not carried by the config datum (see the module docstring).
 LENDER_MANAGER_SPEND_SKH = "6743f4b69446b4e066cfb89daa3d01ef041b6d2646968993be4cec09"
+# The lender-manager dispatch: its withdraw redeemer names the action, and it requires
+# the withdrawal of that action's script from the lender-manager config.
+LENDER_MANAGER_WITHDRAW_SKH = "247065fa7d0f8c5bce2bb379aa76d2cd79ad4e6a7ab207627039a804"
 
 # 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

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

@@ -69,7 +69,7 @@ _STATE_CLASS: dict[EntityKind, type[FluidV4State]] = {
 
 # Everything a malformed record can raise while its datum is decoded. Truncated CBOR
 # raises cbor2's end-of-stream error, which is not a ValueError.
-_DECODE_ERRORS = (
+DECODE_ERRORS = (
     cbor2.CBORDecodeError,
     DeserializeException,
     ValueError,
@@ -187,5 +187,5 @@ def parse_utxo(
         return None
     try:
         return _STATE_CLASS[selector.kind].from_record(info)
-    except _DECODE_ERRORS:
+    except DECODE_ERRORS:
         return None

{charli3_dendrite-1.5.15.dev1 → charli3_dendrite-1.5.16.dev0}/src/charli3_dendrite/lending/fluidtokens_v4/transactions/builder.py

@@ -22,6 +22,8 @@ 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.claim import ClaimSnapshot
+from charli3_dendrite.lending.fluidtokens_v4.transactions.claim import build_claim
 from charli3_dendrite.lending.fluidtokens_v4.transactions.pool_cancel import (
     PoolCancelSnapshot,
 )
@@ -56,6 +58,19 @@ if TYPE_CHECKING:
     from charli3_dendrite.lending.transactions.base import ActionParams
     from charli3_dendrite.lending.transactions.snapshot import PoolActionSnapshot
 
+# The borrower's actions on an existing loan, and the lender's actions.
+_LOAN_ACTIONS = {
+    LendingAction.REPAY,
+    LendingAction.MODIFY_COLLATERAL,
+    LendingAction.RECAST,
+}
+_LENDER_ACTIONS = {
+    LendingAction.POOL_CREATE,
+    LendingAction.POOL_EDIT,
+    LendingAction.POOL_CANCEL,
+    LendingAction.CLAIM_REPAYMENTS,
+}
+
 # Each action's snapshot type and the function that adds it to a builder.
 _ACTIONS: dict[
     LendingAction,
@@ -71,6 +86,7 @@ _ACTIONS: dict[
     LendingAction.POOL_CREATE: (PoolCreateSnapshot, build_pool_create),
     LendingAction.POOL_EDIT: (PoolEditSnapshot, build_pool_edit),
     LendingAction.POOL_CANCEL: (PoolCancelSnapshot, build_pool_cancel),
+    LendingAction.CLAIM_REPAYMENTS: (ClaimSnapshot, build_claim),
 }
 
 
@@ -99,7 +115,7 @@ class FluidTokensV4TxBuilder(AbstractLendingTxBuilder):
 
     @classmethod
     def supported_actions(cls) -> set[LendingAction]:
-        """Borrow, repay, change collateral, recast, and pool create, edit, cancel."""
+        """The borrower's loan actions, the lender's pool actions and the claim."""
         return set(_ACTIONS)
 
     def resolve_snapshot(
@@ -126,11 +142,27 @@ class FluidTokensV4TxBuilder(AbstractLendingTxBuilder):
         - 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.
+        - CLAIM_REPAYMENTS: the repayments owed to the lender bonds
+          ``actor_address``'s key holds at the lender manager, at most
+          ``MAX_REPAYMENTS_PER_CLAIM``; no other field may be set.
         - POOL_CREATE takes lender terms ``ActionParams`` cannot carry: resolve it
           with ``PoolCreateSnapshot.from_backend``.
         """
         if action == LendingAction.BORROW:
             return self._resolve_borrow(backend, params)
+        if action in _LOAN_ACTIONS:
+            return self._resolve_loan_action(backend, action, params)
+        if action in _LENDER_ACTIONS:
+            return self._resolve_lender_action(backend, action, params)
+        raise ValueError(f"{self.protocol()} does not support action {action.value!r}")
+
+    def _resolve_loan_action(
+        self,
+        backend: AbstractBackend,
+        action: LendingAction,
+        params: ActionParams,
+    ) -> PoolActionSnapshot:
+        """REPAY, MODIFY_COLLATERAL or RECAST of the loan in ``params``."""
         if action == LendingAction.REPAY:
             if params.amount:
                 raise ValueError(
@@ -158,6 +190,15 @@ class FluidTokensV4TxBuilder(AbstractLendingTxBuilder):
                 recasts=[(_out_ref(params.loan_utxo, "loan"), params.amount)],
                 borrower_address=params.actor_address,
             )
+        raise ValueError(f"{self.protocol()} does not support action {action.value!r}")
+
+    def _resolve_lender_action(
+        self,
+        backend: AbstractBackend,
+        action: LendingAction,
+        params: ActionParams,
+    ) -> PoolActionSnapshot:
+        """POOL_EDIT, POOL_CANCEL or CLAIM_REPAYMENTS; refuses POOL_CREATE."""
         if action == LendingAction.POOL_EDIT:
             if not params.amount:
                 raise ValueError(
@@ -180,6 +221,21 @@ class FluidTokensV4TxBuilder(AbstractLendingTxBuilder):
                 pools=[_out_ref(params.loan_utxo, "pool")],
                 lender_address=params.actor_address,
             )
+        if action == LendingAction.CLAIM_REPAYMENTS:
+            if (
+                params.loan_utxo
+                or params.amount
+                or params.collateral
+                or (params.borrow_amount)
+            ):
+                raise ValueError(
+                    "CLAIM_REPAYMENTS takes only params.actor_address; name the bonds "
+                    "to claim with ClaimSnapshot.from_backend",
+                )
+            return ClaimSnapshot.from_backend(
+                backend,
+                lender_address=params.actor_address,
+            )
         if action == LendingAction.POOL_CREATE:
             raise ValueError(
                 "POOL_CREATE needs lender terms ActionParams cannot carry; resolve it "

charli3_dendrite-1.5.16.dev0/src/charli3_dendrite/lending/fluidtokens_v4/transactions/claim.py

@@ -0,0 +1,447 @@
+"""FluidTokens V4 repayment claim: a lender collects the repayments of their loans.
+
+A repayment lands at the asset manager, owned by the loan's lender bond, and the asset
+manager releases it to any transaction that spends that bond. Lender bonds sit at the
+lender manager, which lets them move only under an action named by its dispatch; the
+``WithdrawBonds`` action requires every spent bond's lender to sign. A claim spends
+the lender's bonds and the repayments they own, returns each bond to the lender
+manager unchanged (so its automation keeps serving later repayments), and leaves the
+repayments, with any repayment receipts they carry, to the caller's change.
+
+The asset manager checks each repayment against every input of the transaction, so a
+claim's execution budget grows with repayments times inputs: a claim spends at most
+:data:`MAX_REPAYMENTS_PER_CLAIM` repayments, and more take several claims.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Collection
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+from pycardano import Address
+from pycardano import Redeemer
+from pycardano import ScriptHash
+from pycardano import TransactionBuilder
+from pycardano import VerificationKeyHash
+
+from charli3_dendrite.lending.fluidtokens.transactions._common import ref_index
+from charli3_dendrite.lending.fluidtokens.transactions._common import reward_address
+from charli3_dendrite.lending.fluidtokens.transactions.utxos import Utxo
+from charli3_dendrite.lending.fluidtokens.transactions.utxos import ogmios_entry
+from charli3_dendrite.lending.fluidtokens.transactions.utxos import script_ref_by_hash
+from charli3_dendrite.lending.fluidtokens.transactions.utxos import to_pycardano_utxo
+from charli3_dendrite.lending.fluidtokens.transactions.utxos import utxo_from_dict
+from charli3_dendrite.lending.fluidtokens_v4 import constants as c
+from charli3_dendrite.lending.fluidtokens_v4.datums import AssetManagerDatumWithToken
+from charli3_dendrite.lending.fluidtokens_v4.datums import ConfigDatum
+from charli3_dendrite.lending.fluidtokens_v4.datums import LenderManagerConfigDatum
+from charli3_dendrite.lending.fluidtokens_v4.datums import LenderManagerDatum
+from charli3_dendrite.lending.fluidtokens_v4.transactions.common import (
+    add_zero_withdrawals,
+)
+from charli3_dendrite.lending.fluidtokens_v4.transactions.common import ledger_order
+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 signing_key
+from charli3_dendrite.lending.fluidtokens_v4.transactions.redeemers import (
+    AssetManagerWithdrawRedeemer,
+)
+from charli3_dendrite.lending.fluidtokens_v4.transactions.redeemers import (
+    LenderManagerActionWithdrawBonds,
+)
+from charli3_dendrite.lending.fluidtokens_v4.transactions.redeemers import (
+    LenderManagerWithdrawRedeemer,
+)
+from charli3_dendrite.lending.fluidtokens_v4.transactions.redeemers import (
+    LoanSpendRedeemer,
+)
+from charli3_dendrite.lending.transactions.snapshot import PoolActionSnapshot
+
+if TYPE_CHECKING:
+    from pycardano import TransactionOutput
+
+    from charli3_dendrite.backend.backend_base import AbstractBackend
+
+# The most repayments one claim spends: this leaves room for the lender-manager and
+# wallet inputs within the transaction's execution budget.
+MAX_REPAYMENTS_PER_CLAIM = 10
+
+
+def _payment_script(utxo: Utxo) -> str | None:
+    """The script hash of ``utxo``'s payment credential, or None for a key address."""
+    payment = Address.decode(utxo.address).payment_part
+    return payment.payload.hex() if isinstance(payment, ScriptHash) else None
+
+
+@dataclass
+class ClaimPosition:
+    """A UTxO holding lender bonds at the lender manager and the repayments it owns."""
+
+    bond: Utxo
+    repayments: list[Utxo]
+
+    @property
+    def out_ref(self) -> tuple[str, int]:
+        """The bond UTxO's out-ref."""
+        return out_ref_of(self.bond)
+
+    @property
+    def lender_datum(self) -> LenderManagerDatum:
+        """The bond UTxO's lender-manager datum."""
+        if self.bond.datum is None:
+            raise ValueError("lender-bond UTxO is missing its datum")
+        return LenderManagerDatum.from_cbor(self.bond.datum)
+
+    @property
+    def bond_names(self) -> list[bytes]:
+        """The lender bonds the UTxO holds; each is named after its loan."""
+        return [
+            bytes.fromhex(n)
+            for p, n, q in self.bond.assets
+            if p == c.LENDER_BOND_POLICY
+        ]
+
+    @property
+    def owner_pkh(self) -> bytes:
+        """The key hash that must sign to move the bonds."""
+        return signing_key(self.lender_datum.lender_auth, "lender bond")
+
+    def check(self) -> None:
+        """Raise unless the bonds sit at the lender manager and own every repayment."""
+        if _payment_script(self.bond) != c.LENDER_MANAGER_SPEND_SKH:
+            raise ValueError(f"UTxO {self.out_ref} is not at the lender manager")
+        if not self.bond_names:
+            raise ValueError(f"UTxO {self.out_ref} holds no lender bond")
+        if not self.repayments:
+            raise ValueError(f"lender bond UTxO {self.out_ref} owns no repayment")
+        names = set(self.bond_names)
+        for repayment in self.repayments:
+            owner = AssetManagerDatumWithToken.from_cbor(repayment.datum or "")
+            if (
+                bytes(owner.owner_asset.policy_id).hex() != c.LENDER_BOND_POLICY
+                or bytes(owner.owner_asset.asset_name) not in names
+            ):
+                raise ValueError(
+                    f"lender bond UTxO {self.out_ref} does not own repayment "
+                    f"{out_ref_of(repayment)}",
+                )
+
+
+@dataclass
+class ClaimSnapshot(PoolActionSnapshot):
+    """Everything a claim of one lender's repayments needs, resolved from chain."""
+
+    positions: Sequence[ClaimPosition]
+    funding: list[Utxo]
+    config: Utxo
+    lender_manager_config: Utxo
+    lender_manager_spend_script_ref: Utxo
+    lender_manager_withdraw_script_ref: Utxo
+    withdraw_bonds_script_ref: Utxo
+    asset_manager_spend_script_ref: Utxo
+    asset_manager_withdraw_script_ref: Utxo
+
+    @property
+    def ordered_positions(self) -> list[ClaimPosition]:
+        """The positions in the order the ledger sorts their bond inputs."""
+        return sorted(
+            self.positions,
+            key=lambda p: (bytes.fromhex(p.out_ref[0]), p.out_ref[1]),
+        )
+
+    @property
+    def withdraw_bonds_script_hash(self) -> str:
+        """The lender manager's ``WithdrawBonds`` action, named by its config."""
+        if self.lender_manager_config.datum is None:
+            raise ValueError("lender-manager config UTxO is missing its datum")
+        return LenderManagerConfigDatum.from_cbor(
+            self.lender_manager_config.datum,
+        ).withdraw_bonds_action_script_hash.hex()
+
+    @classmethod
+    def from_capture(cls, fix: dict) -> ClaimSnapshot:
+        """Rebuild the snapshot of a captured mainnet claim (for byte-exact replay)."""
+        inputs = [utxo_from_dict(u) for u in fix["inputs"]]
+        refs = [utxo_from_dict(u) for u in fix["ref_inputs"]]
+        config = next(
+            u for u in refs if u.holds(c.CONFIG_NFT_POLICY, c.CONFIG_NFT_NAME)
+        )
+        lender_manager_config = next(
+            u
+            for u in refs
+            if u.holds(
+                c.LENDER_MANAGER_CONFIG_NFT_POLICY,
+                c.LENDER_MANAGER_CONFIG_NFT_NAME,
+            )
+        )
+        scripts = ConfigDatum.from_cbor(config.datum or "")
+        am_spend = scripts.asset_manager_spend_script_hash.hex()
+        repayments = [u for u in inputs if _payment_script(u) == am_spend]
+        positions = []
+        for bond in ledger_order(
+            u for u in inputs if _payment_script(u) == c.LENDER_MANAGER_SPEND_SKH
+        ):
+            names = {n for p, n, _ in bond.assets if p == c.LENDER_BOND_POLICY}
+            positions.append(
+                ClaimPosition(
+                    bond=bond,
+                    repayments=[
+                        u
+                        for u in repayments
+                        if bytes(
+                            AssetManagerDatumWithToken.from_cbor(
+                                u.datum or "",
+                            ).owner_asset.asset_name,
+                        ).hex()
+                        in names
+                    ],
+                ),
+            )
+        used = {out_ref_of(u) for p in positions for u in (p.bond, *p.repayments)}
+        withdraw_bonds = LenderManagerConfigDatum.from_cbor(
+            lender_manager_config.datum or "",
+        ).withdraw_bonds_action_script_hash.hex()
+        return cls(
+            positions=positions,
+            funding=[u for u in inputs if u.out_ref not in used],
+            config=config,
+            lender_manager_config=lender_manager_config,
+            lender_manager_spend_script_ref=script_ref_by_hash(
+                refs,
+                c.LENDER_MANAGER_SPEND_SKH,
+            ),
+            lender_manager_withdraw_script_ref=script_ref_by_hash(
+                refs,
+                c.LENDER_MANAGER_WITHDRAW_SKH,
+            ),
+            withdraw_bonds_script_ref=script_ref_by_hash(refs, withdraw_bonds),
+            asset_manager_spend_script_ref=script_ref_by_hash(refs, am_spend),
+            asset_manager_withdraw_script_ref=script_ref_by_hash(
+                refs,
+                scripts.repayment_policy_id.hex(),
+            ),
+        )
+
+    @classmethod
+    def from_backend(
+        cls,
+        backend: AbstractBackend,
+        *,
+        lender_address: str,
+        bonds: Collection[bytes] | None = None,
+        funding: Sequence[Utxo] | None = None,
+    ) -> ClaimSnapshot:
+        """Resolve a claim of the repayments owed to ``lender_address``'s bonds.
+
+        The bonds are the lender bonds at the lender manager whose lender
+        authorisation is the key of ``lender_address``; the repayments are the
+        asset-manager UTxOs they own, the largest first, at most
+        :data:`MAX_REPAYMENTS_PER_CLAIM` of them. ``bonds`` (loan ids, which name the
+        bonds) limits the claim to those bonds. The lender's UTxOs fund the claim
+        unless ``funding`` is given. Refuses a lender with nothing to claim, a named
+        bond that is not the lender's at the lender manager, and a wallet with no
+        UTxO to fund the claim.
+        """
+        from charli3_dendrite.lending.fluidtokens_v4.transactions.resolve import (
+            config_datum,
+        )
+        from charli3_dendrite.lending.fluidtokens_v4.transactions.resolve import (
+            lender_manager_config_datum,
+        )
+        from charli3_dendrite.lending.fluidtokens_v4.transactions.resolve import (
+            resolve_claim_positions,
+        )
+        from charli3_dendrite.lending.fluidtokens_v4.transactions.resolve import (
+            resolve_config_utxo,
+        )
+        from charli3_dendrite.lending.fluidtokens_v4.transactions.resolve import (
+            resolve_lender_manager_config_utxo,
+        )
+        from charli3_dendrite.lending.fluidtokens_v4.transactions.resolve import (
+            resolve_script,
+        )
+        from charli3_dendrite.lending.fluidtokens_v4.transactions.resolve import (
+            resolve_wallet_funding,
+        )
+
+        payment = Address.decode(lender_address).payment_part
+        if not isinstance(payment, VerificationKeyHash):
+            raise NotImplementedError("only a key address can claim repayments")
+        config = resolve_config_utxo(backend)
+        scripts = config_datum(config)
+        lender_manager_config = resolve_lender_manager_config_utxo(backend)
+        positions = resolve_claim_positions(
+            backend,
+            scripts,
+            lender_pkh=payment.payload,
+            bonds=bonds,
+        )
+        if not positions:
+            raise ValueError(f"{lender_address} has no repayments to claim")
+        spent = [u for p in positions for u in (p.bond, *p.repayments)]
+        resolved = (
+            list(funding)
+            if funding is not None
+            else resolve_wallet_funding(backend, lender_address, exclude=spent)
+        )
+        if funding is None and not resolved:
+            raise ValueError(f"no UTxOs at {lender_address} fund the claim")
+        return cls(
+            positions=positions,
+            funding=resolved,
+            config=config,
+            lender_manager_config=lender_manager_config,
+            lender_manager_spend_script_ref=resolve_script(
+                backend,
+                c.LENDER_MANAGER_SPEND_SKH,
+            ),
+            lender_manager_withdraw_script_ref=resolve_script(
+                backend,
+                c.LENDER_MANAGER_WITHDRAW_SKH,
+            ),
+            withdraw_bonds_script_ref=resolve_script(
+                backend,
+                lender_manager_config_datum(
+                    lender_manager_config,
+                ).withdraw_bonds_action_script_hash,
+            ),
+            asset_manager_spend_script_ref=resolve_script(
+                backend,
+                scripts.asset_manager_spend_script_hash,
+            ),
+            asset_manager_withdraw_script_ref=resolve_script(
+                backend,
+                scripts.repayment_policy_id,
+            ),
+        )
+
+
+def require_sole_lender_manager_action(tx_builder: TransactionBuilder) -> None:
+    """Raise if ``tx_builder`` already spends from or dispatches the lender manager.
+
+    ``WithdrawBonds`` requires the lender of every spent lender-manager UTxO to sign,
+    and one dispatch redeemer names one action for the whole transaction.
+    """
+    spends = any(
+        isinstance(u.output.address.payment_part, ScriptHash)
+        and u.output.address.payment_part.payload.hex() == c.LENDER_MANAGER_SPEND_SKH
+        for u in tx_builder.inputs
+    )
+    dispatches = reward_address(c.LENDER_MANAGER_WITHDRAW_SKH) in (
+        tx_builder.withdrawals or {}
+    )
+    if spends or dispatches:
+        raise ValueError(
+            "a claim must be the only lender-manager action in its transaction",
+        )
+
+
+def build_claim(tx_builder: TransactionBuilder, *, snapshot: ClaimSnapshot) -> None:
+    """Add a claim of every repayment of ``snapshot`` to ``tx_builder``.
+
+    Each bond UTxO returns to the lender manager unchanged; the repayments land in
+    the caller's change. Funding inputs are recorded for Ogmios evaluation. The
+    caller balances, signs (with every bond's lender key) and submits.
+
+    Everything else the caller wants among the transaction's reference inputs must
+    be added before this call, which fills the config indexes last. Discard the
+    builder if this raises.
+    """
+    require_sole_lender_manager_action(tx_builder)
+    positions = snapshot.ordered_positions
+    _check_claim(positions)
+    _add_spends(tx_builder, snapshot=snapshot, positions=positions)
+
+    tx_builder.reference_inputs.add(to_pycardano_utxo(snapshot.config))
+    tx_builder.reference_inputs.add(to_pycardano_utxo(snapshot.lender_manager_config))
+    dispatch = LenderManagerWithdrawRedeemer(
+        config_ref_input_index=0,
+        action=LenderManagerActionWithdrawBonds(),
+    )
+    release = AssetManagerWithdrawRedeemer(config_ref_input_index=0)
+    for script_ref, redeemer in (
+        (snapshot.lender_manager_withdraw_script_ref, dispatch),
+        # The action reads no redeemer.
+        (snapshot.withdraw_bonds_script_ref, LoanSpendRedeemer()),
+        (snapshot.asset_manager_withdraw_script_ref, release),
+    ):
+        tx_builder.add_withdrawal_script(
+            to_pycardano_utxo(script_ref),
+            Redeemer(redeemer),
+        )
+    add_zero_withdrawals(
+        tx_builder,
+        [
+            c.LENDER_MANAGER_WITHDRAW_SKH,
+            snapshot.withdraw_bonds_script_hash,
+            bytes(
+                ConfigDatum.from_cbor(snapshot.config.datum or "").repayment_policy_id,
+            ).hex(),
+        ],
+    )
+    signers = list(tx_builder.required_signers or [])
+    for signer in dict.fromkeys(VerificationKeyHash(p.owner_pkh) for p in positions):
+        if signer not in signers:
+            signers.append(signer)
+    tx_builder.required_signers = signers
+    for position in positions:
+        tx_builder.add_output(_returned_bond(position))
+
+    refs = ref_index(tx_builder)
+    dispatch.config_ref_input_index = refs[out_ref_of(snapshot.lender_manager_config)]
+    release.config_ref_input_index = refs[out_ref_of(snapshot.config)]
+
+
+def _check_claim(positions: Sequence[ClaimPosition]) -> None:
+    """Raise for a claim the contracts or the transaction budget would refuse."""
+    if not positions:
+        raise ValueError("a claim needs at least one lender bond")
+    if sum(len(p.repayments) for p in positions) > MAX_REPAYMENTS_PER_CLAIM:
+        raise ValueError(
+            f"a claim spends at most {MAX_REPAYMENTS_PER_CLAIM} repayments; claim the "
+            "rest in another transaction",
+        )
+    for position in positions:
+        position.check()
+    spent = [out_ref_of(u) for p in positions for u in (p.bond, *p.repayments)]
+    if len(set(spent)) != len(spent):
+        raise ValueError("a claim names each bond and repayment once")
+
+
+def _add_spends(
+    tx_builder: TransactionBuilder,
+    *,
+    snapshot: ClaimSnapshot,
+    positions: Sequence[ClaimPosition],
+) -> None:
+    """Spend the bonds, their repayments and the funding not among them."""
+    for position in positions:
+        tx_builder.add_script_input(
+            to_pycardano_utxo(position.bond),
+            script=to_pycardano_utxo(snapshot.lender_manager_spend_script_ref),
+            redeemer=Redeemer(LoanSpendRedeemer()),
+        )
+        for repayment in position.repayments:
+            tx_builder.add_script_input(
+                to_pycardano_utxo(repayment),
+                script=to_pycardano_utxo(snapshot.asset_manager_spend_script_ref),
+                redeemer=Redeemer(LoanSpendRedeemer()),
+            )
+    spent = {out_ref_of(u) for p in positions for u in (p.bond, *p.repayments)}
+    for funding in snapshot.funding:
+        if funding.out_ref not in spent:
+            tx_builder.add_input(to_pycardano_utxo(funding))
+            snapshot.add_actor_additional_utxo(ogmios_entry(funding))
+
+
+def _returned_bond(position: ClaimPosition) -> TransactionOutput:
+    """The bond UTxO back at the lender manager, as spent.
+
+    ``WithdrawBonds`` checks no output, so a bond whose ADA no longer covers its
+    output's minimum is topped up to it.
+    """
+    output = to_pycardano_utxo(position.bond).output
+    output.amount.coin = max(output.amount.coin, min_ada(output))
+    return output

{charli3_dendrite-1.5.15.dev1 → charli3_dendrite-1.5.16.dev0}/src/charli3_dendrite/lending/fluidtokens_v4/transactions/common.py

@@ -19,6 +19,7 @@ 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.fluidtokens_v4.datums import AuthCardanoSignature
 from charli3_dendrite.lending.transactions.infra import EvalContext
 from charli3_dendrite.lending.units import constr
 from charli3_dendrite.utility import asset_to_value
@@ -72,6 +73,18 @@ def settled_min_ada(address: Address, assets: dict[str, int], datum: Datum) -> i
         lovelace = needed
 
 
+def signing_key(auth: Datum, what: str) -> bytes:
+    """The key hash of an ``AuthorizationMethod`` that is a signature.
+
+    Raises ``NotImplementedError`` for any other authorisation: this library signs
+    with wallet keys only. ``what`` names the owned thing in the message.
+    """
+    alt, fields = constr(auth)
+    if alt != AuthCardanoSignature.CONSTR_ID:
+        raise NotImplementedError(f"only a {what} owned by a key is supported")
+    return bytes(fields[0])
+
+
 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]

{charli3_dendrite-1.5.15.dev1 → charli3_dendrite-1.5.16.dev0}/src/charli3_dendrite/lending/fluidtokens_v4/transactions/pool_action.py

@@ -32,7 +32,6 @@ from charli3_dendrite.lending.fluidtokens.transactions.utxos import Utxo
 from charli3_dendrite.lending.fluidtokens.transactions.utxos import ogmios_entry
 from charli3_dendrite.lending.fluidtokens.transactions.utxos import to_pycardano_utxo
 from charli3_dendrite.lending.fluidtokens_v4 import constants as c
-from charli3_dendrite.lending.fluidtokens_v4.datums import AuthCardanoSignature
 from charli3_dendrite.lending.fluidtokens_v4.datums import AuthCardanoWithdrawScript
 from charli3_dendrite.lending.fluidtokens_v4.datums import PoolDatum
 from charli3_dendrite.lending.fluidtokens_v4.datums import PoolManagerDatum
@@ -42,6 +41,7 @@ from charli3_dendrite.lending.fluidtokens_v4.transactions.common import (
 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 signing_key
 from charli3_dendrite.lending.fluidtokens_v4.transactions.common import sole_nft_name
 from charli3_dendrite.lending.fluidtokens_v4.transactions.common import (
     withdraw_redeemer_position,
@@ -77,10 +77,7 @@ def owner_pkh(manager: PoolManagerDatum) -> bytes:
     Raises ``NotImplementedError`` for an owner that is not a key: such a pool cannot
     be edited or cancelled with a wallet signature.
     """
-    alt, fields = constr(manager.pool_owner_auth)
-    if alt != AuthCardanoSignature.CONSTR_ID:
-        raise NotImplementedError("only a pool manager owned by a key is supported")
-    return bytes(fields[0])
+    return signing_key(manager.pool_owner_auth, "pool manager")
 
 
 @dataclass