charli3_dendrite 1.2.4.dev0__tar.gz → 1.2.5.dev1__tar.gz

{charli3_dendrite-1.2.4.dev0 → charli3_dendrite-1.2.5.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: charli3_dendrite
-Version: 1.2.4.dev0
+Version: 1.2.5.dev1
 Summary: 
 Author: Elder Millenial
 Author-email: eldermillenial@protonmail.com

{charli3_dendrite-1.2.4.dev0 → charli3_dendrite-1.2.5.dev1}/pyproject.toml

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

{charli3_dendrite-1.2.4.dev0 → charli3_dendrite-1.2.5.dev1}/src/charli3_dendrite/__init__.py

@@ -14,6 +14,7 @@ from charli3_dendrite.dexs.amm.spectrum import SpectrumCPPState
 from charli3_dendrite.dexs.amm.splash import SplashCPPBidirState
 from charli3_dendrite.dexs.amm.splash import SplashCPPState
 from charli3_dendrite.dexs.amm.splash import SplashSSPState
+from charli3_dendrite.dexs.amm.splash import SplashCPPRoyaltyState
 from charli3_dendrite.dexs.amm.sundae import SundaeSwapCPPState
 from charli3_dendrite.dexs.amm.sundae import SundaeSwapV3CPPState
 from charli3_dendrite.dexs.amm.vyfi import VyFiCPPState

{charli3_dendrite-1.2.4.dev0 → charli3_dendrite-1.2.5.dev1}/src/charli3_dendrite/dexs/amm/splash.py

@@ -1,6 +1,8 @@
 """Minswap DEX Module."""
 
-from dataclasses import dataclass
+from dataclasses import dataclass, field
+from random import choice
+from string import hexdigits
 from typing import Any
 from typing import List
 from typing import Union
@@ -71,7 +73,11 @@ class SplashOrderDatum(OrderDatum):
     fee: int
     redeemer_address: PlutusFullAddress
     cancel_pkh: bytes
-    permitted_executors: List[bytes]
+    permitted_executors: List[bytes] = field(
+        default_factory=lambda: [
+            b"\\\xb2\xc9h\xe5\xd1\xc7\x19zl\xe7aYg1\n7UE\xd9\xbce\x06:\x96C5\xb2"
+        ]
+    )
 
     def address_source(self) -> Address:
         """This method should return the source address associated with the order."""
@@ -88,6 +94,43 @@ class SplashOrderDatum(OrderDatum):
         """This method should return the type of the order."""
         return OrderType.swap
 
+    @classmethod
+    def create_datum(
+        cls,
+        address_source: Address,
+        in_assets: Assets,
+        out_assets: Assets,
+        batcher_fee: Assets,
+        deposit: Assets,
+        address_target: Address | None = None,
+        datum_target: PlutusData | None = None,
+    ) -> "CSwapOrderDatum":
+        """Create a CSwap order datum."""
+        # Validate ADA-only restriction
+        merged_assets = in_assets + out_assets
+
+        full_address = PlutusFullAddress.from_address(address_source)
+
+        beacon = "".join(choice(hexdigits) for _ in range(56))
+
+        numerator, denominator = float.as_integer_ratio(
+            in_assets.quantity() / out_assets.quantity(),
+        )
+
+        return cls(
+            tag=b"\x00",
+            beacon=beacon,
+            in_asset=AssetClass.from_assets(in_assets),
+            tradable_input=in_assets.quantity(),
+            cost_per_ex_step=batcher_fee.quantity(),
+            min_marginal_output=out_assets.quantity(),
+            output=AssetClass.from_assets(out_assets),
+            base_price=Rationale(numerator=numerator, denominator=denominator),
+            fee=0,
+            redeemer_address=full_address,
+            cancel_pkh=address_source.payment_part.payload,
+        )
+
 
 @dataclass
 class SplashSSPPoolDatum(PoolDatum):
@@ -159,6 +202,31 @@ class SplashCPPBidirPoolDatum(PoolDatum):
         return self.asset_x.assets + self.asset_y.assets
 
 
+@dataclass
+class SplashCPPRoyaltyPoolDatum(PoolDatum):
+    """The pool datum for the Spectrum DEX."""
+
+    pool_nft: AssetClass
+    asset_x: AssetClass
+    asset_y: AssetClass
+    lp_token: AssetClass
+    pool_fee: int
+    treasury_fee: int
+    royalty_fee: int
+    treasury_x: int
+    treasury_y: int
+    royalty_x: int
+    royalty_y: int
+    admin_address: List[PlutusFullAddress]
+    treasury_address: bytes
+    royalty_pub_key: bytes
+    nonce: int
+
+    def pool_pair(self) -> Assets | None:
+        """Returns the pool pair assets if available."""
+        return self.asset_x.assets + self.asset_y.assets
+
+
 @dataclass
 class SwapAction(PlutusData):
     CONSTR_ID = 0
@@ -519,7 +587,9 @@ class SplashCPPState(SplashBaseState, AbstractConstantProductPoolState):
     def post_init(cls, values):
         super().post_init(values)
 
-        datum: SplashCPPPoolDatum = SplashCPPPoolDatum.from_cbor(values["datum_cbor"])
+        datum: SplashCPPPoolDatum = cls.pool_datum_class().from_cbor(
+            values["datum_cbor"]
+        )
 
         values["fee"] = 100000 - datum.pool_fee + datum.treasury_fee
 
@@ -532,25 +602,35 @@ class SplashCPPState(SplashBaseState, AbstractConstantProductPoolState):
         # https://github.com/splashprotocol/splash-core/blob/9fd951054ac7143de6acf491f36d1073e729ba90/plutarch-validators/WhalePoolsDex/PContracts/PPool.hs#L367
         values["inactive"] = assets.quantity() < 100000000
 
+    def _treasury_x(self) -> int:
+        return self.pool_datum.treasury_x
+
+    def _treasury_y(self) -> int:
+        return self.pool_datum.treasury_y
+
     def get_amount_out(
         self,
         asset: Assets,
         precise: bool = True,
     ) -> tuple[Assets, float]:
-        amount_out, float = super().get_amount_out(asset=asset, precise=precise)
+        amount_out, slippage = super().get_amount_out(asset=asset, precise=precise)
+
+        if isinstance(self.fee, (int, float)) or len(self.fee) == 1:
+            fee = self.fee
+        else:
+            fee = self.fee[0] if asset.unit() == self.assets.unit_a else self.fee[1]
 
-        pool_datum = self.pool_datum
-        fee = pool_datum.pool_fee - pool_datum.treasury_fee
+        fee = 100000 - fee
         dx = asset.quantity()
         dxf = dx * fee
         rx = self.assets[asset.unit()]
 
         if asset.unit() == self.assets.unit():
-            ry = self.assets.quantity(1) + pool_datum.treasury_y
-            rx += pool_datum.treasury_x
+            ry = self.assets.quantity(1) + self._treasury_y()
+            rx += self._treasury_x()
         else:
-            ry = self.assets.quantity(0) + pool_datum.treasury_x
-            rx += pool_datum.treasury_y
+            ry = self.assets.quantity(0) + self._treasury_x()
+            rx += self._treasury_y()
 
         # Check to make sure the output passes invariant, and decrease until it does
         dy = -amount_out.quantity()
@@ -567,7 +647,7 @@ class SplashCPPState(SplashBaseState, AbstractConstantProductPoolState):
             assert -dy * (rx * 100000 + dxf) <= ry * dxf
             assert -dx * (ry * 100000 + dyf) <= rx * dyf
 
-        return amount_out, float
+        return amount_out, slippage
 
     def swap_utxo(
         self,
@@ -688,8 +768,8 @@ class SplashCPPBidirState(SplashCPPState):
         )
 
         values["fee"] = [
-            (100000 - datum.pool_fee_x + datum.treasury_fee) // 10,
-            (100000 - datum.pool_fee_y + datum.treasury_fee) // 10,
+            (100000 - datum.pool_fee_x + datum.treasury_fee),
+            (100000 - datum.pool_fee_y + datum.treasury_fee),
         ]
 
         assets = values["assets"]
@@ -698,3 +778,146 @@ class SplashCPPBidirState(SplashCPPState):
 
         # Verify pool is active
         values["inactive"] = assets.quantity() < 100000000
+
+
+class SplashCPPRoyaltyState(SplashCPPState):
+    """Splash StableSwap Pool State."""
+
+    fee: int = 30
+    _batcher = Assets(lovelace=1000000)
+    _deposit = Assets(lovelace=1500000)
+
+    def _treasury_x(self) -> int:
+        return self.pool_datum.treasury_x + self.pool_datum.royalty_x
+
+    def _treasury_y(self) -> int:
+        return self.pool_datum.treasury_y + self.pool_datum.royalty_y
+
+    @classmethod
+    def pool_selector(cls) -> PoolSelector:
+        return PoolSelector(
+            addresses=[
+                "addr1w89ksjnfu7ys02tedvslc9g2wk90tu5qte0dt4dge60hdugfqe64t",
+            ],
+        )
+
+    @classmethod
+    def pool_datum_class(self) -> type[SplashCPPRoyaltyPoolDatum]:
+        return SplashCPPRoyaltyPoolDatum
+
+    @classmethod
+    def post_init(cls, values):
+        super().post_init(values)
+
+        datum: SplashCPPRoyaltyPoolDatum = SplashCPPRoyaltyPoolDatum.from_cbor(
+            values["datum_cbor"],
+        )
+
+        values["fee"] = 100000 - datum.pool_fee + datum.treasury_fee + datum.royalty_fee
+
+        assets = values["assets"]
+        assets.root[assets.unit(0)] -= datum.treasury_x + datum.royalty_x
+        assets.root[assets.unit(1)] -= datum.treasury_y + datum.royalty_y
+
+        # Verify pool is active
+        values["inactive"] = assets.quantity() < 100000000
+
+    # def swap_utxo(
+    #     self,
+    #     address_source: Address,
+    #     in_assets: Assets,
+    #     out_assets: Assets,
+    #     tx_builder: TransactionBuilder | None = None,
+    #     extra_assets: Assets | None = None,
+    #     address_target: Address | None = None,
+    #     datum_target: PlutusData | None = None,
+    # ) -> tuple[TransactionOutput | None, PlutusData]:
+    #     assert self.tx_hash is not None
+    #     assert self.pool_nft is not None
+    #     assert self.lp_tokens is not None
+    #     assert tx_builder is not None
+
+    #     order_info = get_backend().get_pool_in_tx(
+    #         self.tx_hash,
+    #         assets=[self.pool_nft.unit()],
+    #         addresses=self.pool_selector().addresses,
+    #     )
+
+    #     # Get the output assets
+    #     out_assets, _ = self.get_amount_out(asset=in_assets)
+
+    #     # Create the output redeemer
+    #     redeemer = Redeemer(
+    #         CPPoolRedeemer(
+    #             action=2,
+    #             self_index=-1,
+    #         ),
+    #     )
+
+    #     # Create the pool input UTxO
+    #     pool_datum_class = self.pool_datum_class()
+    #     pool_datum = pool_datum_class.from_cbor(
+    #         self.pool_datum.to_cbor(),
+    #     )
+    #     assets = self.assets + self.pool_nft + self.lp_tokens
+    #     assets.root[self.assets.unit()] += (
+    #         pool_datum.treasury_x + self.pool_datum.royalty_x
+    #     )
+    #     assets.root[self.assets.unit(1)] += (
+    #         pool_datum.treasury_y + self.pool_datum.royalty_y
+    #     )
+    #     input_utxo = UTxO(
+    #         TransactionInput(
+    #             transaction_id=TransactionId(bytes.fromhex(self.tx_hash)),
+    #             index=self.tx_index,
+    #         ),
+    #         output=TransactionOutput(
+    #             address=order_info[0].address,
+    #             amount=asset_to_value(assets),
+    #             datum=self.pool_datum,
+    #         ),
+    #     )
+
+    #     # Create the pool output UTxO
+    #     new_assets = Assets.model_validate(assets.model_dump())
+    #     new_assets.root[in_assets.unit()] += in_assets.quantity()
+    #     new_assets.root[out_assets.unit()] += -out_assets.quantity()
+    #     new_pool_datum = pool_datum_class.from_cbor(
+    #         self.pool_datum.to_cbor(),
+    #     )
+
+    #     if in_assets.unit() == new_pool_datum.asset_x.assets.unit():
+    #         new_pool_datum.treasury_x += int(
+    #             in_assets.quantity() * new_pool_datum.treasury_fee // 100000,
+    #         )
+    #         new_pool_datum.royalty_x += int(
+    #             in_assets.quantity() * new_pool_datum.royalty_fee // 100000,
+    #         )
+    #     elif in_assets.unit() == new_pool_datum.asset_y.assets.unit():
+    #         new_pool_datum.treasury_y += int(
+    #             in_assets.quantity() * new_pool_datum.treasury_fee // 100000,
+    #         )
+    #         new_pool_datum.royalty_y += int(
+    #             in_assets.quantity() * new_pool_datum.royalty_fee // 100000,
+    #         )
+    #     else:
+    #         raise ValueError("Invalid input asset")
+
+    #     txo = TransactionOutput(
+    #         address=order_info[0].address,
+    #         amount=asset_to_value(new_assets),
+    #         datum=new_pool_datum,
+    #     )
+
+    #     # Add the script input
+    #     pool_hash = Address.decode(order_info[0].address).payment_part.payload
+    #     script = (
+    #         get_backend()
+    #         .get_script_from_address(
+    #             Address(payment_part=ScriptHash(payload=pool_hash)),
+    #         )
+    #         .to_utxo()
+    #     )
+    #     tx_builder.add_script_input(utxo=input_utxo, script=script, redeemer=redeemer)
+
+    #     return txo, self.pool_datum