charli3_dendrite 1.6.3.dev0__tar.gz → 1.6.4.dev0__tar.gz

{charli3_dendrite-1.6.3.dev0 → charli3_dendrite-1.6.4.dev0}/PKG-INFO

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

{charli3_dendrite-1.6.3.dev0 → charli3_dendrite-1.6.4.dev0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "charli3_dendrite"
-version = "1.6.3-dev0"
+version = "1.6.4-dev0"
 description = ""
 authors = ["Elder Millenial <eldermillenial@protonmail.com>"]
 readme = "README.md"
@@ -50,7 +50,7 @@ module = ["pycardano", "pycardano.*", "dotenv", "nox", "uplc", "uplc.*"]
 ignore_missing_imports = true
 
 [tool.bumpversion]
-current_version = "1.6.3-dev0"
+current_version = "1.6.4-dev0"
 parse = """(?x)
     (?P<major>\\d+)\\.
     (?P<minor>\\d+)\\.

{charli3_dendrite-1.6.3.dev0 → charli3_dendrite-1.6.4.dev0}/src/charli3_dendrite/dexs/amm/amm_base.py

@@ -1,5 +1,6 @@
 """Module providing base classes for AMM pools."""
 
+import inspect
 from abc import abstractmethod
 from decimal import Decimal
 from typing import Any
@@ -80,6 +81,7 @@ class AbstractPoolState(AbstractPairState):
         address_target: Address | None = None,
         datum_target: PlutusData | None = None,
         minimum_receive: Assets | None = None,
+        swap_all: bool = False,
     ) -> PlutusData:
         """Create a swap datum for the pool.
 
@@ -95,13 +97,21 @@ class AbstractPoolState(AbstractPairState):
             Defaults to None.
             minimum_receive (Assets | None, optional): Overrides the baked on-chain
             minimum; fee and deposit still size from out_assets. Defaults to None.
+            swap_all (bool, optional): The order swaps whatever amount of the input
+            token it holds when executed; use it for an order funded by another
+            order's output, whose exact input is unknown when the datum is built.
+            Fee and deposit still size from in_assets. Defaults to False.
 
         Returns:
             PlutusData: The created swap datum.
 
         Raises:
-            ValueError: If more than one asset is supplied as input or output.
+            ValueError: If more than one asset is supplied as input or output, or if
+            swap_all is set and the order datum cannot express it.
         """
+        datum_class = self.order_datum_class()
+        swap_all_kwargs = self._swap_all_kwargs(datum_class, swap_all)
+
         if not self.swap_forward and address_target is not None:
             print(  # noqa: T201
                 f"{self.__class__.__name__} does not support swap forwarding.",
@@ -111,7 +121,7 @@ class AbstractPoolState(AbstractPairState):
         # fee and deposit are still derived from the EXACT ``out_assets`` so relaxing
         # the floor never under-fees the order — only the step's ``minimum_receive``
         # loosens. Same output unit, so swap direction and lp_asset are unaffected.
-        return self.order_datum_class().create_datum(
+        return datum_class.create_datum(
             address_source=address_source,
             in_assets=in_assets,
             out_assets=out_assets if minimum_receive is None else minimum_receive,
@@ -123,6 +133,53 @@ class AbstractPoolState(AbstractPairState):
             deposit=self.deposit(in_assets=in_assets, out_assets=out_assets),
             address_target=address_target,
             datum_target=datum_target,
+            **swap_all_kwargs,
+        )
+
+    def _swap_all_kwargs(
+        self,
+        datum_class: type[PlutusData],
+        swap_all: bool,
+    ) -> dict[str, bool]:
+        """The ``create_datum`` keyword arguments that request a swap-all order.
+
+        Empty unless ``swap_all`` is set, so an order datum without swap-all support
+        is built exactly as before.
+
+        Args:
+            datum_class (type[PlutusData]): The order datum class building the order.
+            swap_all (bool): Whether a swap-all order is requested.
+
+        Returns:
+            dict[str, bool]: The keyword arguments to pass to ``create_datum``.
+
+        Raises:
+            ValueError: If swap_all is set and ``datum_class`` has no
+            ``create_datum`` taking a ``swap_all`` parameter.
+        """
+        if not swap_all:
+            return {}
+        create_datum = getattr(datum_class, "create_datum", None)
+        if (
+            create_datum is None
+            or "swap_all" not in inspect.signature(create_datum).parameters
+        ):
+            raise self._swap_all_error(
+                f"{datum_class.__name__} has no swap-all form",
+            )
+        return {"swap_all": True}
+
+    def _swap_all_error(self, reason: str) -> ValueError:
+        """The error for a swap-all order this pool cannot build.
+
+        Args:
+            reason (str): Why the order cannot swap whatever amount it holds.
+
+        Returns:
+            ValueError: An error naming the pool class and the reason.
+        """
+        return ValueError(
+            f"{self.__class__.__name__} cannot build a swap-all order: {reason}.",
         )
 
     def swap_utxo(
@@ -135,6 +192,7 @@ class AbstractPoolState(AbstractPairState):
         address_target: Address | None = None,
         datum_target: PlutusData | None = None,
         minimum_receive: Assets | None = None,
+        swap_all: bool = False,
     ) -> tuple[TransactionOutput | None, PlutusData]:
         """Create a swap UTXO for the pool.
 
@@ -151,13 +209,19 @@ class AbstractPoolState(AbstractPairState):
             Defaults to None.
             minimum_receive (Assets | None, optional): Overrides the baked on-chain
             minimum; fee and deposit still size from out_assets. Defaults to None.
+            swap_all (bool, optional): The order swaps whatever amount of the input
+            token it holds when executed; use it for an order funded by another
+            order's output, whose exact input is unknown when the datum is built.
+            Fee, deposit and the order value still size from in_assets. Defaults to
+            False.
 
         Returns:
             tuple[TransactionOutput, PlutusData]: A tuple containing the created
             transaction output and the swap datum.
 
         Raises:
-            ValueError: If more than one asset is supplied as input or output.
+            ValueError: If more than one asset is supplied as input or output, or if
+            swap_all is set and the order datum cannot express it.
         """
         # Basic checks
         if len(in_assets) != 1 or len(out_assets) != 1:
@@ -174,6 +238,9 @@ class AbstractPoolState(AbstractPairState):
             address_target=address_target,
             datum_target=datum_target,
             minimum_receive=minimum_receive,
+            # Passed only when set, so a swap_datum override without swap-all
+            # support is called exactly as before.
+            **({"swap_all": True} if swap_all else {}),
         )
 
         in_assets.root["lovelace"] = (

{charli3_dendrite-1.6.3.dev0 → charli3_dendrite-1.6.4.dev0}/src/charli3_dendrite/dexs/amm/minswap.py

@@ -316,8 +316,21 @@ class SwapExactInV2(PlutusData):
     killable: Union[BoolTrue, BoolFalse]
 
     @classmethod
-    def from_assets(cls, in_asset: Assets, out_asset: Assets) -> "SwapExactInV2":
-        """Parse an Assets object into a SwapExactInV2 datum."""
+    def from_assets(
+        cls,
+        in_asset: Assets,
+        out_asset: Assets,
+        deducted_amount: int | None = None,
+    ) -> "SwapExactInV2":
+        """Parse an Assets object into a SwapExactInV2 datum.
+
+        Args:
+            in_asset: The asset swapped in.
+            out_asset: The asset swapped out; its quantity is the minimum receive.
+            deducted_amount: When None, the order swaps exactly the quantity of
+                ``in_asset``. Otherwise the order swaps everything it holds of the
+                input asset less ``deducted_amount`` (``SAOAll``).
+        """
         assert len(in_asset) == 1
 
         merged_assets = in_asset + out_asset
@@ -326,7 +339,11 @@ class SwapExactInV2(PlutusData):
             BoolTrue() if in_asset.unit() == merged_assets.unit() else BoolFalse()
         )
 
-        option = SAOSpecificAmount(swap_amount=in_asset.quantity())
+        option: SAOSpecificAmount | SAOAll
+        if deducted_amount is None:
+            option = SAOSpecificAmount(swap_amount=in_asset.quantity())
+        else:
+            option = SAOAll(deducted_amount=deducted_amount)
 
         return cls(
             a_to_b_direction=direction,
@@ -544,10 +561,29 @@ class MinswapV2OrderDatum(OrderDatum):
         deposit: Assets,
         address_target: Address | None = None,
         datum_target: PlutusData | None = None,
+        swap_all: bool = False,
     ):
-        """Create an order datum."""
+        """Create an order datum.
+
+        With ``swap_all`` the order swaps whatever it holds of the input asset when
+        executed (``SAOAll``) instead of exactly ``in_assets``. The validator swaps
+        the held quantity less ``deducted_amount`` and pays the batcher fee from the
+        remaining ADA, so a token input deducts nothing and an ADA input deducts the
+        batcher fee and deposit the order carries alongside its input.
+        """
         full_address_source = PlutusFullAddress.from_address(address_source)
-        step = SwapExactInV2.from_assets(in_asset=in_assets, out_asset=out_assets)
+        deducted_amount = None
+        if swap_all:
+            deducted_amount = (
+                batcher_fee.quantity() + deposit.quantity()
+                if in_assets.unit() == "lovelace"
+                else 0
+            )
+        step = SwapExactInV2.from_assets(
+            in_asset=in_assets,
+            out_asset=out_assets,
+            deducted_amount=deducted_amount,
+        )
 
         # Minswap V2's ExtraDatum carries only the 32-byte HASH of the datum the
         # batcher attaches to the forwarded output (Constr 1 for a datum-hash output,

{charli3_dendrite-1.6.3.dev0 → charli3_dendrite-1.6.4.dev0}/src/charli3_dendrite/dexs/amm/spectrum.py

@@ -367,6 +367,7 @@ class SpectrumCPPState(AbstractConstantProductPoolState):
         address_target: Address | None = None,
         datum_target: PlutusData | None = None,
         minimum_receive: Assets | None = None,
+        swap_all: bool = False,
     ) -> PlutusData:
         """Create a PlutusData object representing a swap datum.
 
@@ -380,10 +381,20 @@ class SpectrumCPPState(AbstractConstantProductPoolState):
             Defaults to None.
             datum_target (PlutusData | None): The target datum for the swap.
             Defaults to None.
+            minimum_receive (Assets | None): Overrides the baked on-chain minimum.
+            Defaults to None.
+            swap_all (bool): Request an order that swaps whatever amount of the
+            input token it holds. Defaults to False.
 
         Returns:
             PlutusData: A PlutusData object representing the swap datum.
+
+        Raises:
+            ValueError: If ``swap_all`` is set; the Spectrum order datum has no
+            swap-all form.
         """
+        swap_all_kwargs = self._swap_all_kwargs(SpectrumOrderDatum, swap_all)
+
         if self.swap_forward and address_source is not None:
             print(  # noqa: T201
                 f"{self.__class__.__name__} does not support swap forwarding.",
@@ -407,6 +418,7 @@ class SpectrumCPPState(AbstractConstantProductPoolState):
             ],
             volume_fee=volume_fee,
             pool_token=self.pool_nft,
+            **swap_all_kwargs,
         )
 
     @classmethod

{charli3_dendrite-1.6.3.dev0 → charli3_dendrite-1.6.4.dev0}/src/charli3_dendrite/dexs/amm/sundae.py

@@ -34,6 +34,10 @@ from charli3_dendrite.dexs.core.errors import InvalidPoolError
 from charli3_dendrite.dexs.core.errors import NoAssetsError
 from charli3_dendrite.dexs.core.errors import NotAPoolError
 
+# A swap-all SundaeSwap V3 stableswap order offers this multiple of its expected
+# input, so any realistic delivery is swapped in full.
+SWAP_ALL_OFFER_MULTIPLE = 2
+
 
 @dataclass
 class AtoB(PlutusData):
@@ -616,8 +620,11 @@ class SundaeSwapCPPState(AbstractConstantProductPoolState):
         address_target: Address | None = None,
         datum_target: PlutusData | None = None,
         minimum_receive: Assets | None = None,
+        swap_all: bool = False,
     ) -> PlutusData:
         """Create a swap datum."""
+        swap_all_kwargs = self._swap_all_kwargs(SundaeOrderDatum, swap_all)
+
         if self.swap_forward and address_target is not None:
             print(f"{self.__class__.__name__} does not support swap forwarding.")
 
@@ -629,6 +636,7 @@ class SundaeSwapCPPState(AbstractConstantProductPoolState):
             in_assets=in_assets,
             out_assets=out_assets if minimum_receive is None else minimum_receive,
             fee=self.batcher_fee(in_assets=in_assets, out_assets=out_assets).quantity(),
+            **swap_all_kwargs,
         )
 
 
@@ -769,7 +777,20 @@ class SundaeSwapV3CPPState(AbstractConstantProductPoolState):
         address_target: Address | None = None,
         datum_target: PlutusData | None = None,
         minimum_receive: Assets | None = None,
+        swap_all: bool = False,
     ) -> PlutusData:
+        """Create a swap datum.
+
+        Raises:
+            ValueError: If ``swap_all`` is set. The constant-product pool swaps
+                exactly the order's offer, so the order cannot swap an amount
+                unknown when the datum is built.
+        """
+        if swap_all:
+            raise self._swap_all_error(
+                "the constant-product pool swaps exactly the order's offer",
+            )
+
         ident = bytes.fromhex(self.pool_nft.unit()[64:])
 
         datum = SundaeV3OrderDatum.create_datum(
@@ -948,13 +969,38 @@ class SundaeSwapV3StableSwap(AbstractStableSwapPoolState):
         address_target: Address | None = None,
         datum_target: PlutusData | None = None,
         minimum_receive: Assets | None = None,
+        swap_all: bool = False,
     ) -> PlutusData:
+        """Create a swap datum.
+
+        The stableswap pool swaps the smaller of the order's offer and the input it
+        holds. With ``swap_all`` the offer is ``SWAP_ALL_OFFER_MULTIPLE`` times
+        ``in_assets``, so the order swaps whatever amount of the input token it
+        holds when executed. The order value is still built from ``in_assets``.
+
+        Raises:
+            ValueError: If ``swap_all`` is set with an ADA input. An ADA offer
+                shares the order value with the protocol fee and deposit, so
+                swapping all of it would leave no ADA on the output.
+        """
+        if swap_all and in_assets.unit() == "lovelace":
+            raise self._swap_all_error(
+                "an ADA input cannot swap whatever arrives because the deposit "
+                "and fee share the input value",
+            )
+
         ident = bytes.fromhex(self.pool_nft.unit()[64:])
 
+        offer = in_assets
+        if swap_all:
+            offer = Assets(
+                root={in_assets.unit(): SWAP_ALL_OFFER_MULTIPLE * in_assets.quantity()},
+            )
+
         datum = SundaeV3OrderDatum.create_datum(
             ident=ident,
             address_source=address_source,
-            in_assets=in_assets,
+            in_assets=offer,
             out_assets=out_assets if minimum_receive is None else minimum_receive,
             fee=self.batcher_fee(in_assets=in_assets, out_assets=out_assets).quantity(),
             address_target=address_target,

{charli3_dendrite-1.6.3.dev0 → charli3_dendrite-1.6.4.dev0}/src/charli3_dendrite/dexs/amm/wingriders.py

@@ -921,8 +921,12 @@ class WingRidersV2SSPState(AbstractStableSwapPoolState, WingRidersV2CPPState):
         address_target: Address | None = None,
         datum_target: PlutusData | None = None,
         minimum_receive: Assets | None = None,
+        swap_all: bool = False,
     ) -> PlutusData:
-        return self.order_datum_class().create_datum(
+        datum_class = self.order_datum_class()
+        swap_all_kwargs = self._swap_all_kwargs(datum_class, swap_all)
+
+        return datum_class.create_datum(
             address_source=address_source,
             in_assets=in_assets,
             out_assets=out_assets if minimum_receive is None else minimum_receive,
@@ -936,4 +940,5 @@ class WingRidersV2SSPState(AbstractStableSwapPoolState, WingRidersV2CPPState):
             datum_target=datum_target,
             a_scale=self.asset_mulitipliers[0],
             b_scale=self.asset_mulitipliers[1],
+            **swap_all_kwargs,
         )