charli3_dendrite 1.5.4.dev0__tar.gz → 1.5.5.dev0__tar.gz

{charli3_dendrite-1.5.4.dev0 → charli3_dendrite-1.5.5.dev0}/PKG-INFO

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

{charli3_dendrite-1.5.4.dev0 → charli3_dendrite-1.5.5.dev0}/pyproject.toml

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

{charli3_dendrite-1.5.4.dev0 → charli3_dendrite-1.5.5.dev0}/src/charli3_dendrite/dexs/amm/dano.py

@@ -994,7 +994,8 @@ class DanoCLMMState(AbstractConstantLiquidityPoolState):
         A fresh chain parse carries the dex NFT *inside* the assets bag (extracted
         later), not as a ``dex_nft`` key, so it takes the full parse path. Mirrors
         VyFi / WingRiders V2; makes the serialize→reingest round-trip idempotent
-        for both the dendrite model_dump form and steelswap's net silver.
+        for both the dendrite model_dump form and a downstream consumer's
+        net-reserves view.
         """
         if "dex_nft" in values:
             if not isinstance(values["assets"], Assets):

{charli3_dendrite-1.5.4.dev0 → charli3_dendrite-1.5.5.dev0}/src/charli3_dendrite/lending/danogo/datums.py

@@ -14,12 +14,7 @@ from typing import List
 from pycardano import IndefiniteList
 from pycardano import PlutusData
 
-
-def asset_unit(policy: bytes, name: bytes) -> str:
-    """Dendrite unit string for a (policy, name) asset ('lovelace' for ADA)."""
-    if not policy and not name:
-        return "lovelace"
-    return policy.hex() + name.hex()
+from charli3_dendrite.lending.units import asset_unit
 
 
 @dataclass

{charli3_dendrite-1.5.4.dev0 → charli3_dendrite-1.5.5.dev0}/src/charli3_dendrite/lending/danogo/oracles/redeemer.py

@@ -37,6 +37,7 @@ from enum import IntEnum
 import cbor2  # type: ignore[import-not-found]
 
 from charli3_dendrite.lending.danogo.datums import asset_unit
+from charli3_dendrite.lending.units import constr_alt
 
 
 class UTxOTarget(IntEnum):
@@ -126,14 +127,8 @@ _CONSTR_TAG_EXT = 1280
 _CONSTR_EXT_OFFSET = 7
 _RDMR_BORROW_FIELD = 4
 
-
-def _constr_alt(tag: int) -> int:
-    """CBOR constructor tag -> alternative index (pycardano convention)."""
-    if _CONSTR_TAG_MIN <= tag <= _CONSTR_TAG_MAX:
-        return tag - _CONSTR_TAG_MIN
-    if tag >= _CONSTR_TAG_EXT:
-        return tag - _CONSTR_TAG_EXT + _CONSTR_EXT_OFFSET
-    raise ValueError(f"not a constructor tag: {tag}")
+# Thin alias over the shared primitive; kept for existing danogo call sites.
+_constr_alt = constr_alt
 
 
 def _alt_constr_tag(alt: int) -> int:

charli3_dendrite-1.5.5.dev0/src/charli3_dendrite/lending/fluidtokens/__init__.py

@@ -0,0 +1 @@
+"""FluidTokens V3 lending protocol integration."""

charli3_dendrite-1.5.5.dev0/src/charli3_dendrite/lending/fluidtokens/constants.py

@@ -0,0 +1,207 @@
+"""FluidTokens V3 mainnet coordinates.
+
+The protocol is parameterized by a single config NFT; the config UTxO datum holds
+every protocol script hash / policy id. The constants below are the live mainnet
+deployment coordinates (a static fallback), and `resolve_addresses` re-reads the live
+config datum through the backend so entity discovery self-heals across a redeploy,
+falling back to the constants when the datum cannot be read (e.g. a non-dbsync
+backend).
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+from typing import TypedDict
+
+import cbor2  # type: ignore[import-not-found]
+from pycardano import Address
+from pycardano import Network
+from pycardano import ScriptHash
+
+if TYPE_CHECKING:
+    from charli3_dendrite.backend.backend_base import AbstractBackend
+
+PROTOCOL_CONFIG_NFT_POLICY = "219832152b2c489358f4c02a1818d312a851b1f55774ae881e33a907"
+PROTOCOL_CONFIG_NFT_NAME = "706172616d6574657273"  # "parameters"
+
+# Mainnet deployment: config-datum field -> hash / policy id.
+POOL_POLICY = "befbcb19919ff8ce5323d123c835da8e7653a098ad482271a72b72f2"
+REQUEST_POLICY = "a37578f027ae878115cc70cd0909ddc855d67b6dd3bd038a757bd221"
+BORROWER_BOND_POLICY = "eadc69a5d2d1357acc9b9d49ec5390fcdf6e080c7a40139917223dcb"
+LENDER_BOND_POLICY = "bcd713bb7858d4b08738bed90ee7068d8f9b38d02e0cae0b45ac7a9b"
+LOAN_POLICY = "30f1095a8a2acb68bb0ffa193e18e004b6dd3e12b5d9c2375a1d5c41"
+REPAYMENT_POLICY = "1fb02a2a8f89d1484141e57bd370587773b3dbd69d45fec93a6b2a94"
+
+POOL_SPEND_SKH = "ad353a777c817f4d9d6c4324930f5c6128400517ec9dae0461e034cd"
+REQUEST_SPEND_SKH = "dc9003272dbd7fc5d19ce4f0eb3a92bec2c4ffcbd58c8ce4493888bc"
+LOAN_SPEND_SKH = "5abbaa2eb177b574707fa3617e3436295d45d7795e0874623a9504da"
+LOAN_CLAIM_ACTION_SKH = "79cc329af69d79ba85f56a04c0e8512306eb7ed98a5bd0c878485910"
+LOAN_REPAY_ACTION_SKH = "5fcd23d021add45fdb25e8c7c674d6e2dbc445feafe246c5a0fab02f"
+LOAN_CHANGE_COLLATERAL_ACTION_SKH = (
+    "6ca3b95015bbef6237db91322132ebd3ac0c3850f79096eb6f42e1af"
+)
+LOAN_RECAST_ACTION_SKH = "696d17c79d1276945d0e96d2368a7c48b431afbe880c008da8fee0f2"
+ASSET_MANAGER_SPEND_SKH = "e20678c018fe01a9b0d116a5a1bfa57e2efe8520645ca303d2c26a0e"
+
+# Mainnet bech32 addresses where each entity's UTxOs live (payment cred = the
+# general_spend instance for that entity; stake part carries the action withdraw cred).
+POOL_ADDRESS = "addr1zxkn2wnh0jqh7nvad3pjfyc0t3sjssq9zlkfmtsyv8srfnfhmnz9plgputfxf9gqn86lwgyk0qu3n59haevkkdx0klmqspeu5h"  # noqa: E501
+LOAN_ADDRESS = "addr1z9dth23wk9mm2ars073kzl35xc5463wh090qsarz822sfksvadkn2cntfnulwwvs7nq44jmrlzdfhtyvate92x7k67ysyhqtnf"  # noqa: E501
+REQUEST_ADDRESS = "addr1z8wfqqe89k7hl3w3nnj0p6e6j2lv938le02cer8yfyug30xfmmkg85yfq8c7nrysz63g2sq8ttmt8gn7jmgfqy995d4s48shzc"  # noqa: E501
+
+
+class FluidScriptAddresses(TypedDict):
+    """Resolved entity coordinates used by the loader/builder."""
+
+    pool: str
+    loan: str
+    request: str
+    pool_policy: str
+    loan_policy: str
+    request_policy: str
+
+
+# Config datum layout: Constr(0, [ ... ]). Fields 0-1 are governance credentials; 2-15
+# are the policy ids / script hashes below; 16-21 are reserved (currently empty / zero).
+_CONFIG_CONSTR_0 = 121
+_CONFIG_MIN_FIELDS = 16
+_CONFIG_FIELD_IX = {
+    "pool_policy": 2,
+    "request_policy": 3,
+    "borrower_bond_policy": 4,
+    "lender_bond_policy": 5,
+    "loan_policy": 6,
+    "repayment_policy": 7,
+    "pool_spend_skh": 8,
+    "request_spend_skh": 9,
+    "loan_spend_skh": 10,
+    "loan_claim_action_skh": 11,
+    "loan_repay_action_skh": 12,
+    "loan_change_collateral_action_skh": 13,
+    "loan_recast_action_skh": 14,
+    "asset_manager_spend_skh": 15,
+}
+
+
+@dataclass(frozen=True)
+class FluidConfig:
+    """The protocol policy ids / script hashes carried by the config NFT datum.
+
+    Every field is a hex hash. :meth:`parse` decodes the on-chain config datum;
+    :meth:`defaults` returns the static mainnet constants defined in this module, used
+    as a fallback when the live datum cannot be read.
+    """
+
+    pool_policy: str
+    request_policy: str
+    borrower_bond_policy: str
+    lender_bond_policy: str
+    loan_policy: str
+    repayment_policy: str
+    pool_spend_skh: str
+    request_spend_skh: str
+    loan_spend_skh: str
+    loan_claim_action_skh: str
+    loan_repay_action_skh: str
+    loan_change_collateral_action_skh: str
+    loan_recast_action_skh: str
+    asset_manager_spend_skh: str
+
+    @classmethod
+    def parse(cls, datum_cbor: str) -> FluidConfig:
+        """Decode the config NFT datum cbor-hex into a :class:`FluidConfig`.
+
+        Reads the known policy/script-hash fields (2-15) and tolerates the reserved
+        tail (16+). Raises :class:`ValueError` if the datum is not the expected
+        ``Constr(0, [...])`` with at least the known fields, all bytes.
+        """
+        try:
+            top = cbor2.loads(bytes.fromhex(datum_cbor))
+        except (ValueError, cbor2.CBORDecodeError) as exc:
+            raise ValueError(f"config datum: undecodable cbor: {exc}") from exc
+        if not isinstance(top, cbor2.CBORTag) or top.tag != _CONFIG_CONSTR_0:
+            raise ValueError("config datum: expected Constr(0, ...)")
+        fields = top.value
+        if not isinstance(fields, list) or len(fields) < _CONFIG_MIN_FIELDS:
+            raise ValueError(
+                f"config datum: expected >= {_CONFIG_MIN_FIELDS} fields",
+            )
+
+        def _hash(name: str) -> str:
+            value = fields[_CONFIG_FIELD_IX[name]]
+            if not isinstance(value, bytes):
+                raise ValueError(f"config datum: field {name} is not bytes")
+            return value.hex()
+
+        return cls(**{name: _hash(name) for name in _CONFIG_FIELD_IX})
+
+    @classmethod
+    def defaults(cls) -> FluidConfig:
+        """The static mainnet constants defined in this module."""
+        return cls(
+            pool_policy=POOL_POLICY,
+            request_policy=REQUEST_POLICY,
+            borrower_bond_policy=BORROWER_BOND_POLICY,
+            lender_bond_policy=LENDER_BOND_POLICY,
+            loan_policy=LOAN_POLICY,
+            repayment_policy=REPAYMENT_POLICY,
+            pool_spend_skh=POOL_SPEND_SKH,
+            request_spend_skh=REQUEST_SPEND_SKH,
+            loan_spend_skh=LOAN_SPEND_SKH,
+            loan_claim_action_skh=LOAN_CLAIM_ACTION_SKH,
+            loan_repay_action_skh=LOAN_REPAY_ACTION_SKH,
+            loan_change_collateral_action_skh=LOAN_CHANGE_COLLATERAL_ACTION_SKH,
+            loan_recast_action_skh=LOAN_RECAST_ACTION_SKH,
+            asset_manager_spend_skh=ASSET_MANAGER_SPEND_SKH,
+        )
+
+
+def _payment_address(script_hash_hex: str) -> str:
+    """A mainnet payment-credential (enterprise) address for a spend script hash.
+
+    Entity UTxOs sit at base addresses whose stake part is not carried by the config
+    datum, but the backend discovers them by payment credential only, so a
+    payment-credential address is the stable, redeploy-proof identity to match on.
+    """
+    return Address(
+        payment_part=ScriptHash(bytes.fromhex(script_hash_hex)),
+        network=Network.MAINNET,
+    ).encode()
+
+
+def resolve_config(backend: AbstractBackend) -> FluidConfig:
+    """Read the live config NFT datum into a :class:`FluidConfig`.
+
+    Falls back to :meth:`FluidConfig.defaults` when the datum cannot be read or parsed
+    (e.g. a non-dbsync backend, a missing config UTxO, or an unexpected datum shape) so
+    the loader keeps working offline / against a degraded backend.
+    """
+    try:
+        # Imported lazily: `resolve` imports this module, so a top-level import cycles.
+        from charli3_dendrite.lending.fluidtokens.transactions.resolve import (
+            resolve_config_utxo,
+        )
+
+        utxo = resolve_config_utxo(backend)
+        return FluidConfig.parse(utxo.datum)
+    except (TypeError, ValueError, IndexError, KeyError, AttributeError):
+        return FluidConfig.defaults()
+
+
+def resolve_addresses(backend: AbstractBackend) -> FluidScriptAddresses:
+    """Resolve the entity coordinate set, preferring the live config NFT datum.
+
+    Re-reads the config datum through `backend` so pool / loan / request discovery
+    self-heals across a protocol redeploy (new spend scripts / policies); falls back to
+    the static mainnet constants when the datum cannot be read. Addresses are
+    payment-credential identities (see :func:`_payment_address`).
+    """
+    config = resolve_config(backend)
+    return FluidScriptAddresses(
+        pool=_payment_address(config.pool_spend_skh),
+        loan=_payment_address(config.loan_spend_skh),
+        request=_payment_address(config.request_spend_skh),
+        pool_policy=config.pool_policy,
+        loan_policy=config.loan_policy,
+        request_policy=config.request_policy,
+    )

charli3_dendrite-1.5.5.dev0/src/charli3_dendrite/lending/fluidtokens/datums.py

@@ -0,0 +1,232 @@
+"""pycardano mirrors of the deployed FluidTokens V3 datums (mainnet)."""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import List
+from typing import TypeAlias
+
+from pycardano import Datum
+from pycardano import IndefiniteList
+from pycardano import PlutusData
+
+from charli3_dendrite.lending.units import asset_unit
+
+
+@dataclass
+class Asset(PlutusData):
+    """(policy_id, asset_name) as a `Constr`; ADA is (b"", b"")."""
+
+    CONSTR_ID = 0
+    policy_id: bytes
+    asset_name: bytes
+
+    def unit(self) -> str:
+        """Dendrite unit string ('lovelace' for ADA)."""
+        return asset_unit(self.policy_id, self.asset_name)
+
+
+@dataclass
+class CollateralAsset(PlutusData):
+    """A collateral type: policy, optional asset name, and its oracle token."""
+
+    CONSTR_ID = 0
+    policy_id: bytes
+    maybe_asset_name: Datum  # Option<AssetName>: Constr0([name]) / Constr1([])
+    oracle_token_asset: Asset
+
+
+@dataclass
+class NoLiquidationFullCollateralClaim(PlutusData):
+    """LiquidationMode variant: on default the lender claims all collateral."""
+
+    CONSTR_ID = 0
+
+
+@dataclass
+class NoLiquidationDutchAuctionClaim(PlutusData):
+    """LiquidationMode variant: on default the collateral is dutch-auctioned."""
+
+    CONSTR_ID = 1
+
+
+@dataclass
+class Liquidation(PlutusData):
+    """LiquidationMode variant: liquidate against a loan-to-value threshold.
+
+    Three fields, matching the deployed datum and `ft-cardano-loans-v3` lib
+    (`general.ak`): the LTV is ``l_tv / l_tv_divider``, and the sign of
+    ``partial_liquidation_penalty_per_mille`` encodes the borrower-equity rule
+    (``< 0`` the borrower loses all collateral; ``>= 0`` the lender pays back the
+    difference; ``> 0`` that per-mille of the debt is kept as a penalty).
+    """
+
+    CONSTR_ID = 2
+    l_tv: int
+    l_tv_divider: int
+    partial_liquidation_penalty_per_mille: int
+
+
+@dataclass
+class InterestOnRemainingPrincipal(PlutusData):
+    """RepaymentMode variant: interest accrues on the remaining principal."""
+
+    CONSTR_ID = 0
+    max_possible_recasts: int
+
+
+@dataclass
+class PrincipalAndInterestOnInstallments(PlutusData):
+    """RepaymentMode variant: principal and interest split across installments."""
+
+    CONSTR_ID = 1
+
+
+@dataclass
+class PerpetualLoan(PlutusData):
+    """RepaymentMode variant: perpetual loan with a linear APY increase."""
+
+    CONSTR_ID = 2
+    apy_increase_linear_coefficient: int
+    max_possible_recasts: int
+
+
+# Unions; parse via from_primitive dispatch where needed.
+LiquidationMode: TypeAlias = Datum
+RepaymentMode: TypeAlias = Datum
+
+
+@dataclass
+class CommonData(PlutusData):
+    """Loan terms shared by pool, request, and loan datums."""
+
+    CONSTR_ID = 0
+    principal_asset: Asset
+    principal_oracle_asset: Asset
+    interest_rate: int
+    installment_period: int
+    total_installments: int
+    initial_grace_period: int
+    liquidation_mode: LiquidationMode
+    repayment_mode: RepaymentMode
+    repayment_time_window: int
+    penalty_fee_for_late_repayment: int
+    repayment_receipts: Datum  # Bool: Constr0/Constr1
+
+
+@dataclass
+class AuthCardanoSignature(PlutusData):
+    """AuthorizationMethod variant: authorize by a verification-key hash."""
+
+    CONSTR_ID = 0
+    key_hash: bytes
+
+
+@dataclass
+class AuthCardanoSpendScript(PlutusData):
+    """AuthorizationMethod variant: authorize by a spending script hash."""
+
+    CONSTR_ID = 1
+    script_hash: bytes
+
+
+@dataclass
+class AuthCardanoWithdrawScript(PlutusData):
+    """AuthorizationMethod variant: authorize by a withdrawal script hash."""
+
+    CONSTR_ID = 2
+    script_hash: bytes
+
+
+@dataclass
+class AuthCardanoMintScript(PlutusData):
+    """AuthorizationMethod variant: authorize by a minting script hash."""
+
+    CONSTR_ID = 3
+    script_hash: bytes
+
+
+@dataclass
+class PoolDatum(PlutusData):
+    """Deployed PoolDatum — Constr0, 10 fields.
+
+    ``collateral_options``, ``min_collateral``, and ``min_collateral_divider`` follow
+    Plutus list serialization: empty is a definite-length empty array (``80``);
+    non-empty is an indefinite-length array (``9f..ff``). A plain ``list`` field
+    reproduces the empty case but emits a DEFINITE array when non-empty, diverging
+    from on-chain, so ``__post_init__`` rebuilds each non-empty list as an
+    ``IndefiniteList`` (coercing decoded raw ``collateral_options`` entries back into
+    ``CollateralAsset``).
+    """
+
+    CONSTR_ID = 0
+    permissioned_condition_script_hash: bytes
+    extra_data: Datum
+    common_data: CommonData
+    lender_auth: Datum  # AuthorizationMethod union
+    lender_bond_address: Datum  # pycardano Address constr
+    lender_bond_inline_datum_hash: bytes
+    collateral_options: List[CollateralAsset] | IndefiniteList
+    min_collateral: List[int] | IndefiniteList
+    min_collateral_divider: List[int] | IndefiniteList
+    dynamic_collateral_price: Datum  # Bool Constr0/Constr1
+
+    def __post_init__(self) -> None:
+        """Pin the list fields to their conditional on-chain encoding."""
+        options = [
+            o if isinstance(o, CollateralAsset) else CollateralAsset.from_primitive(o)
+            for o in self.collateral_options
+        ]
+        self.collateral_options = IndefiniteList(options) if options else options
+        self.min_collateral = (
+            IndefiniteList(list(self.min_collateral))
+            if len(self.min_collateral)
+            else self.min_collateral
+        )
+        self.min_collateral_divider = (
+            IndefiniteList(list(self.min_collateral_divider))
+            if len(self.min_collateral_divider)
+            else self.min_collateral_divider
+        )
+
+
+@dataclass
+class LoanDatum(PlutusData):
+    """Deployed LoanDatum — Constr0, 17 fields."""
+
+    CONSTR_ID = 0
+    done_recasts: int
+    principal_amount: int
+    lend_date: int
+    repaid_installments: int
+    interest_rate: int
+    total_installments: int
+    principal_asset: Asset
+    principal_oracle_asset: Asset
+    installment_period: int
+    initial_grace_period: int
+    liquidation_mode: LiquidationMode
+    repayment_mode: RepaymentMode
+    repayment_time_window: int
+    penalty_fee_for_late_repayment: int
+    repayment_receipts: Datum
+    origin_id: bytes
+    collateral: CollateralAsset
+
+
+@dataclass
+class RequestDatum(PlutusData):
+    """Deployed RequestDatum — Constr0, 12 fields."""
+
+    CONSTR_ID = 0
+    permissioned_condition_script_hash: bytes
+    extra_data: Datum
+    common_data: CommonData
+    borrower_auth: Datum
+    borrower_address: Datum
+    collateral: CollateralAsset
+    min_principal: int
+    min_principal_divider: int
+    max_principal: int
+    dynamic_collateral_price: Datum
+    request_expiration: int
+    request_expiration_penalty: int