Muesliswap

MuesliSwap DEX Module.

MuesliCLPoolDatum dataclass

Bases: MuesliPoolDatum

The pool datum for MuesliSwap constant liquidity pools.

Source code in src/charli3_dendrite/dexs/amm/muesli.py

@dataclass
class MuesliCLPoolDatum(MuesliPoolDatum):
    """The pool datum for MuesliSwap constant liquidity pools."""

    upper: PreciseFloat
    lower: PreciseFloat
    price_sqrt: PreciseFloat
    unknown: int

MuesliCancelRedeemer dataclass

Bases: PlutusData

The cancel redeemer for MuesliSwap.

Source code in src/charli3_dendrite/dexs/amm/muesli.py

@dataclass
class MuesliCancelRedeemer(PlutusData):
    """The cancel redeemer for MuesliSwap."""

    CONSTR_ID = 0

MuesliOrderConfig dataclass

Bases: PlutusData

The order configuration for MuesliSwap.

Source code in src/charli3_dendrite/dexs/amm/muesli.py

@dataclass
class MuesliOrderConfig(PlutusData):
    """The order configuration for MuesliSwap."""

    CONSTR_ID = 0

    full_address: PlutusFullAddress
    token_out_policy: bytes
    token_out_name: bytes
    token_in_policy: bytes
    token_in_name: bytes
    min_receive: int
    unknown: Union[MuesliSometimesNone, PlutusNone]
    in_amount: int

MuesliOrderDatum dataclass

Bases: OrderDatum

The order datum for MuesliSwap.

Source code in src/charli3_dendrite/dexs/amm/muesli.py

@dataclass
class MuesliOrderDatum(OrderDatum):
    """The order datum for MuesliSwap."""

    value: MuesliOrderConfig

    @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,
    ):
        """Create a MuesliSwap order datum."""
        full_address = PlutusFullAddress.from_address(address_source)

        if in_assets.unit() == "lovelace":
            token_in_policy = b""
            token_in_name = b""
        else:
            token_in_policy = bytes.fromhex(in_assets.unit()[:56])
            token_in_name = bytes.fromhex(in_assets.unit()[56:])

        if out_assets.unit() == "lovelace":
            token_out_policy = b""
            token_out_name = b""
        else:
            token_out_policy = bytes.fromhex(out_assets.unit()[:56])
            token_out_name = bytes.fromhex(out_assets.unit()[56:])

        config = MuesliOrderConfig(
            full_address=full_address,
            token_in_policy=token_in_policy,
            token_in_name=token_in_name,
            token_out_policy=token_out_policy,
            token_out_name=token_out_name,
            min_receive=out_assets.quantity(),
            unknown=PlutusNone(),
            in_amount=batcher_fee.quantity() + deposit.quantity(),
        )

        return cls(value=config)

    def address_source(self) -> str:
        return self.value.full_address.to_address()

    def requested_amount(self) -> Assets:
        token_out = self.value.token_out_policy.hex() + self.value.token_out_name.hex()
        if token_out == "":
            token_out = "lovelace"
        return Assets({token_out: self.value.min_receive})

    def order_type(self) -> OrderType:
        return OrderType.swap

create_datum(address_source: Address, in_assets: Assets, out_assets: Assets, batcher_fee: Assets, deposit: Assets, address_target: Address | None = None, datum_target: PlutusData | None = None) classmethod

Create a MuesliSwap order datum.

Source code in src/charli3_dendrite/dexs/amm/muesli.py

@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,
):
    """Create a MuesliSwap order datum."""
    full_address = PlutusFullAddress.from_address(address_source)

    if in_assets.unit() == "lovelace":
        token_in_policy = b""
        token_in_name = b""
    else:
        token_in_policy = bytes.fromhex(in_assets.unit()[:56])
        token_in_name = bytes.fromhex(in_assets.unit()[56:])

    if out_assets.unit() == "lovelace":
        token_out_policy = b""
        token_out_name = b""
    else:
        token_out_policy = bytes.fromhex(out_assets.unit()[:56])
        token_out_name = bytes.fromhex(out_assets.unit()[56:])

    config = MuesliOrderConfig(
        full_address=full_address,
        token_in_policy=token_in_policy,
        token_in_name=token_in_name,
        token_out_policy=token_out_policy,
        token_out_name=token_out_name,
        min_receive=out_assets.quantity(),
        unknown=PlutusNone(),
        in_amount=batcher_fee.quantity() + deposit.quantity(),
    )

    return cls(value=config)

MuesliPoolDatum dataclass

Bases: PoolDatum

The pool datum for MuesliSwap.

Source code in src/charli3_dendrite/dexs/amm/muesli.py

@dataclass
class MuesliPoolDatum(PoolDatum):
    """The pool datum for MuesliSwap."""

    asset_a: AssetClass
    asset_b: AssetClass
    lp: int
    fee: int

    def pool_pair(self) -> Assets | None:
        return self.asset_a.assets + self.asset_b.assets

MuesliSometimesNone dataclass

Bases: PlutusData

A dataclass that can be None.

Source code in src/charli3_dendrite/dexs/amm/muesli.py

@dataclass
class MuesliSometimesNone(PlutusData):
    """A dataclass that can be None."""

    CONSTR_ID = 0

MuesliSwapCLPState

Bases: AbstractConstantLiquidityPoolState, MuesliSwapCPPState

The MuesliSwap constant liquidity pool state.

Source code in src/charli3_dendrite/dexs/amm/muesli.py

class MuesliSwapCLPState(AbstractConstantLiquidityPoolState, MuesliSwapCPPState):
    """The MuesliSwap constant liquidity pool state."""

    inactive: bool = True

    @classmethod
    def dex_policy(cls) -> list[str]:
        return [
            # "de9b756719341e79785aa13c164e7fe68c189ed04d61c9876b2fe53f4d7565736c69537761705f414d4d",
            # "ffcdbb9155da0602280c04d8b36efde35e3416567f9241aff09552694d7565736c69537761705f414d4d",
            "f33bf12af1c23d660e29ebb0d3206b0bfc56ffd87ffafe2d36c42a454d7565736c69537761705f634c50",  # constant liquidity pools
            # "a8512101cb1163cc218e616bb4d4070349a1c9395313f1323cc583634d7565736c695377617054657374506f6f6c",  # test pool policy
        ]

    @classmethod
    def pool_datum_class(cls) -> type[MuesliCLPoolDatum]:
        return MuesliCLPoolDatum

MuesliSwapCPPState

Bases: AbstractConstantProductPoolState

The MuesliSwap constant product pool state.

Source code in src/charli3_dendrite/dexs/amm/muesli.py

class MuesliSwapCPPState(AbstractConstantProductPoolState):
    """The MuesliSwap constant product pool state."""

    fee: int = 30
    _batcher = Assets(lovelace=950000)
    _deposit = Assets(lovelace=1700000)
    _test_pool: ClassVar[
        str
    ] = "a8512101cb1163cc218e616bb4d4070349a1c9395313f1323cc583634d7565736c695377617054657374506f6f6c"
    _stake_address: ClassVar[Address] = Address.from_primitive(
        "addr1zyq0kyrml023kwjk8zr86d5gaxrt5w8lxnah8r6m6s4jp4g3r6dxnzml343sx8jweqn4vn3fz2kj8kgu9czghx0jrsyqqktyhv",
    )
    _reference_utxo: ClassVar[UTxO | None] = None

    @classmethod
    def dex(cls) -> str:
        return "MuesliSwap"

    @classmethod
    def order_selector(self) -> list[str]:
        return [self._stake_address.encode()]

    @classmethod
    def pool_selector(cls) -> PoolSelector:
        return PoolSelector(
            addresses=[
                "addr1w9cy2gmar6cpn8yymll93lnd7lw96f27kn2p3eq5d4tjr7qkh3tzd",
                "addr1w85t4tvj3rwf40wqnx6x72kqq6c6stra7jvkupnlqrqyarg2m74rn",
                "addr1w8djr38pct9dpewvv7k67xuh45xpj5f9hyzs3cp939j0csc6nhwme",
            ],
            assets=cls.dex_policy(),
        )

    @property
    def swap_forward(self) -> bool:
        return False

    @classmethod
    def reference_utxo(cls) -> UTxO | None:
        if cls._reference_utxo is None:
            script_reference = get_backend().get_script_from_address(cls._stake_address)

            if script_reference is None:
                return None

            script_bytes = bytes.fromhex(script_reference.script)
            script = cls.default_script_class()(script_bytes)

            cls._reference_utxo = UTxO(
                input=TransactionInput(
                    transaction_id=TransactionId(
                        bytes.fromhex(
                            "7e4142b7a040eae45d14513000adf91ab42da33a1bd5ccffcfe851b3d93e1e5e",
                        ),
                    ),
                    index=1,
                ),
                output=TransactionOutput(
                    address=Address.decode(
                        "addr1v9p0rc57dzkz7gg97dmsns8hngsuxl956xe6myjldaug7hse4elc6",
                    ),
                    amount=Value(coin=24269610),
                    script=script,
                ),
            )

        return cls._reference_utxo

    @property
    def stake_address(self) -> Address:
        return self._stake_address

    @classmethod
    def order_datum_class(cls) -> type[MuesliOrderDatum]:
        return MuesliOrderDatum

    @classmethod
    def pool_datum_class(cls) -> type[MuesliPoolDatum]:
        return MuesliPoolDatum

    @property
    def pool_id(self) -> str:
        """A unique identifier for the pool."""
        return self.pool_nft.unit()

    @classmethod
    def dex_policy(cls) -> list[str]:
        return [
            "de9b756719341e79785aa13c164e7fe68c189ed04d61c9876b2fe53f4d7565736c69537761705f414d4d",
            "ffcdbb9155da0602280c04d8b36efde35e3416567f9241aff09552694d7565736c69537761705f414d4d",
            # "f33bf12af1c23d660e29ebb0d3206b0bfc56ffd87ffafe2d36c42a454d7565736c69537761705f634c50",  # constant liquidity pools
            # "a8512101cb1163cc218e616bb4d4070349a1c9395313f1323cc583634d7565736c695377617054657374506f6f6c",  # test pool policy
        ]

    @classmethod
    def extract_dex_nft(cls, values: dict[str, Any]) -> Optional[Assets]:
        """Extract the dex nft from the UTXO.

        Some DEXs put a DEX nft into the pool UTXO.

        This function checks to see if the DEX nft is in the UTXO if the DEX policy is
        defined.

        If the dex nft is in the values, this value is skipped because it is assumed
        that this utxo has already been parsed.

        Args:
            values: The pool UTXO inputs.

        Returns:
            Assets: None or the dex nft.
        """
        dex_nft = super().extract_dex_nft(values)

        if cls._test_pool in dex_nft:
            raise InvalidPoolError("This is a test pool.")

        return dex_nft

    @classmethod
    def extract_pool_nft(cls, values: dict[str, Any]) -> Optional[Assets]:
        """Extract the dex nft from the UTXO.

        Some DEXs put a DEX nft into the pool UTXO.

        This function checks to see if the DEX nft is in the UTXO if the DEX policy is
        defined.

        If the dex nft is in the values, this value is skipped because it is assumed
        that this utxo has already been parsed.

        Args:
            values: The pool UTXO inputs.

        Returns:
            Assets: None or the dex nft.
        """
        assets = values["assets"]

        if "pool_nft" in values:
            pool_nft = Assets(root=values["pool_nft"])
        else:
            nfts = [asset for asset, quantity in assets.items() if quantity == 1]
            if len(nfts) != 1:
                raise InvalidPoolError(
                    f"MuesliSwap pools must have exactly one pool nft: assets={assets}",
                )
            pool_nft = Assets(**{nfts[0]: assets.root.pop(nfts[0])})
            values["pool_nft"] = pool_nft

        return pool_nft

    @classmethod
    def default_script_class(self) -> type[PlutusV1Script] | type[PlutusV2Script]:
        return PlutusV2Script

    @classmethod
    def cancel_redeemer(cls) -> PlutusData:
        return Redeemer(MuesliCancelRedeemer())

pool_id: str property

A unique identifier for the pool.

extract_dex_nft(values: dict[str, Any]) -> Optional[Assets] classmethod

Extract the dex nft from the UTXO.

Some DEXs put a DEX nft into the pool UTXO.

This function checks to see if the DEX nft is in the UTXO if the DEX policy is defined.

If the dex nft is in the values, this value is skipped because it is assumed that this utxo has already been parsed.

Parameters:

Name	Type	Description	Default
values	dict[str, Any]	The pool UTXO inputs.	required

Returns:

Name	Type	Description
Assets	Optional[Assets]	None or the dex nft.

Source code in src/charli3_dendrite/dexs/amm/muesli.py

@classmethod
def extract_dex_nft(cls, values: dict[str, Any]) -> Optional[Assets]:
    """Extract the dex nft from the UTXO.

    Some DEXs put a DEX nft into the pool UTXO.

    This function checks to see if the DEX nft is in the UTXO if the DEX policy is
    defined.

    If the dex nft is in the values, this value is skipped because it is assumed
    that this utxo has already been parsed.

    Args:
        values: The pool UTXO inputs.

    Returns:
        Assets: None or the dex nft.
    """
    dex_nft = super().extract_dex_nft(values)

    if cls._test_pool in dex_nft:
        raise InvalidPoolError("This is a test pool.")

    return dex_nft

extract_pool_nft(values: dict[str, Any]) -> Optional[Assets] classmethod

Extract the dex nft from the UTXO.

Some DEXs put a DEX nft into the pool UTXO.

This function checks to see if the DEX nft is in the UTXO if the DEX policy is defined.

If the dex nft is in the values, this value is skipped because it is assumed that this utxo has already been parsed.

Parameters:

Name	Type	Description	Default
values	dict[str, Any]	The pool UTXO inputs.	required

Returns:

Name	Type	Description
Assets	Optional[Assets]	None or the dex nft.

Source code in src/charli3_dendrite/dexs/amm/muesli.py

@classmethod
def extract_pool_nft(cls, values: dict[str, Any]) -> Optional[Assets]:
    """Extract the dex nft from the UTXO.

    Some DEXs put a DEX nft into the pool UTXO.

    This function checks to see if the DEX nft is in the UTXO if the DEX policy is
    defined.

    If the dex nft is in the values, this value is skipped because it is assumed
    that this utxo has already been parsed.

    Args:
        values: The pool UTXO inputs.

    Returns:
        Assets: None or the dex nft.
    """
    assets = values["assets"]

    if "pool_nft" in values:
        pool_nft = Assets(root=values["pool_nft"])
    else:
        nfts = [asset for asset, quantity in assets.items() if quantity == 1]
        if len(nfts) != 1:
            raise InvalidPoolError(
                f"MuesliSwap pools must have exactly one pool nft: assets={assets}",
            )
        pool_nft = Assets(**{nfts[0]: assets.root.pop(nfts[0])})
        values["pool_nft"] = pool_nft

    return pool_nft

PreciseFloat dataclass

Bases: PlutusData

A precise float dataclass.

Source code in src/charli3_dendrite/dexs/amm/muesli.py

@dataclass
class PreciseFloat(PlutusData):
    """A precise float dataclass."""

    CONSTR_ID = 0

    numerator: int
    denominator: int