tristero 0.1.7__py3-none-any.whl → 0.3.0__py3-none-any.whl

tristero/permit2.py

@@ -1,50 +1,60 @@
+from dataclasses import dataclass
 import logging
-from typing import Any, List, Optional, TypeVar, cast
+import random
+import time
+from typing import Any, Dict, List, Optional, TypeVar
 from eth_account import Account
 from eth_account.datastructures import SignedMessage, SignedTransaction
-from eth_account.signers.base import BaseAccount
 from eth_account.signers.local import LocalAccount
-from eth_account.types import TransactionDictType
-from pydantic import BaseModel, ConfigDict, Field, field_validator
+from eth_account.messages import encode_typed_data
+from pydantic import BaseModel, ConfigDict, Field
 from pydantic.alias_generators import to_camel
 from web3 import AsyncBaseProvider, AsyncWeb3
-from eth_typing import Address, ChecksumAddress
-import time
-import math
-import random
-import web3
 from web3.contract import AsyncContract
 from functools import cache, lru_cache
 import json
-from pathlib import Path
 from importlib import resources as impresources
 
 from web3 import Web3
 from web3.eth import AsyncEth
+from eth_utils import to_checksum_address
 
-from .api import (
-    _WRAPPED_GAS_ADDRESSES,
-    get_quote,
-    _PERMIT2_CONTRACT_ADDRESSES,
-    ChainID,
+from tristero.api import get_quote
+
+from .data import (
+    get_permit2_addr,
+    get_wrapped_gas_addr,
+)
+from .eip712 import (
+    EIP712OrderParameters,
+    EIP712TokenPermissions,
+    EIP712SignedOrder,
+    EIP712PermitWitnessTransferFromOrder,
+    EIP712CloseWithSwap,
+    get_escrow_domain,
+    get_close_with_swap_types,
 )
 
 logger = logging.getLogger(__name__)
 
 P = TypeVar("P", bound=AsyncBaseProvider)
 
+DEFAULT_PERMIT2_ADDRESS = "0x000000000022D473030F116dDEE9F6B43aC78BA3"
+
 PERMIT2_ABI_FILE = impresources.files("tristero.files") / "permit2_abi.json"
 ERC20_ABI_FILE = impresources.files("tristero.files") / "erc20_abi.json"
+
 PERMIT2_ABI = json.loads(PERMIT2_ABI_FILE.read_text())
 ERC20_ABI = json.loads(ERC20_ABI_FILE.read_text())
 
 
 @lru_cache(maxsize=None)
-def get_permit2(eth: AsyncEth, permit2_address: str):
+def get_permit2_contract(eth: AsyncEth, permit2_address: str):
     return eth.contract(
         address=Web3.to_checksum_address(permit2_address), abi=PERMIT2_ABI
     )
 
+
 @cache
 def get_erc20_contract(w3: AsyncWeb3[P], token_address: str) -> AsyncContract:
     """Get ERC20 contract instance."""
@@ -152,6 +162,11 @@ async def get_permit2_unordered_nonce(c: AsyncContract, wallet_address: str):
     return wordPos
 
 
+def get_random_nonce() -> int:
+    """Generate a random nonce for EIP-712 signing."""
+    return random.randint(2**128, 2**256 - 1)
+
+
 async def prepare_data_for_signature(
     eth: AsyncEth,
     sell_data: ChainData,
@@ -173,7 +188,6 @@ async def prepare_data_for_signature(
     Returns:
         SignatureData with domain, types, primaryType, and message for signing
     """
-    # Validate required fields
     if not quote.order_data.parameters.min_quantity:
         raise ValueError("Min quantity is required in the order_data.parameters")
 
@@ -183,18 +197,16 @@ async def prepare_data_for_signature(
     if not quote.order_data.deadline:
         raise ValueError("Deadline is required in the order_data")
 
-    from_chain = ChainID(str(sell_data.chain_id))
+    from_chain = str(sell_data.chain_id)
 
     deadline = quote.order_data.deadline
 
-    # Handle native token address conversion
     token_address = (
-        _WRAPPED_GAS_ADDRESSES[from_chain]
+        get_wrapped_gas_addr(from_chain)
         if sell_data.token.address == "native"
         else sell_data.token.address
     )
 
-    # Build witness object
     witness = SignedOrder(
         sender=wallet_address,
         parameters=OrderParameters(
@@ -212,24 +224,21 @@ async def prepare_data_for_signature(
         custom_data=quote.order_data.custom_data or [],
     )
 
-    # Get Permit2 address
-    permit2_address = _PERMIT2_CONTRACT_ADDRESSES.get(from_chain)
+    permit2_address = get_permit2_addr(from_chain)
     if not permit2_address:
         raise ValueError("Permit2 not deployed on this chain.")
 
     spender = quote.order_data.router_address
     nonce = await get_permit2_unordered_nonce(
-        get_permit2(eth, permit2_address), wallet_address
+        get_permit2_contract(eth, permit2_address), wallet_address
     )
 
-    # EIP-712 domain
     domain = EIP712Domain(
         name="Permit2",
         chain_id=sell_data.chain_id,
         verifying_contract=permit2_address,
     )
 
-    # EIP-712 types
     types = {
         "TokenPermissions": [
             {"name": "token", "type": "address"},
@@ -261,7 +270,6 @@ async def prepare_data_for_signature(
         ],
     }
 
-    # Build message
     message = PermitMessage(
         permitted=TokenPermissions(
             token=token_address,
@@ -309,48 +317,223 @@ async def sign_permit2(
         wallet_address,
         Quote(order_data=order_data),
     )
-    # print(
-    #     "Signing the following full message:",
-    #     json.dumps(to_sign.model_dump(mode="json", by_alias=True)),
-    # )
     signature = account.sign_typed_data(
         full_message=to_sign.model_dump(mode="json", by_alias=True)
     )
     return (to_sign, signature)
 
 
+def sign_margin_order(
+    quote: Dict[str, Any],
+    private_key: str,
+    permit2_address: str = DEFAULT_PERMIT2_ADDRESS,
+    nonce: Optional[int] = None,
+) -> Dict[str, Any]:
+    """
+    Sign a margin order using EIP-712 typed data.
+    
+    Args:
+        quote: Quote response from get_margin_quote
+        private_key: Private key for signing
+        permit2_address: Permit2 contract address
+        nonce: Optional nonce (random if not provided)
+    
+    Returns:
+        Signed order payload ready for submission
+    """
+    order_data = quote.get("order_data")
+    if not isinstance(order_data, dict):
+        raise ValueError("quote missing order_data")
+
+    chain_id_str = quote.get("chain_id")
+    if isinstance(chain_id_str, dict) and "value" in chain_id_str:
+        chain_id = int(chain_id_str["value"])
+    else:
+        chain_id = int(chain_id_str)
+
+    domain_data = {
+        "name": "Permit2",
+        "chainId": chain_id,
+        "verifyingContract": to_checksum_address(permit2_address),
+    }
+
+    parameters = EIP712OrderParameters(
+        srcAsset=order_data["parameters"]["src_asset"],
+        dstAsset=order_data["parameters"]["dst_asset"],
+        srcQuantity=int(order_data["parameters"]["src_quantity"]),
+        dstQuantity=int(order_data["parameters"]["dst_quantity"]),
+        minQuantity=int(order_data["parameters"]["min_quantity"]),
+        darkSalt=int(order_data["parameters"]["dark_salt"]),
+    )
+
+    signed_order = EIP712SignedOrder(
+        sender=order_data["sender_wallet_address"],
+        parameters=parameters,
+        deadline=int(order_data["deadline"]),
+        target=order_data["target_wallet_address"],
+        filler=order_data["filler_wallet_address"],
+        orderType=str(order_data["order_type"]),
+        customData=[
+            bytes.fromhex(cd[2:]) if cd.startswith("0x") else bytes.fromhex(cd)
+            for cd in order_data.get("custom_data", [])
+        ],
+    )
+
+    token_permissions = EIP712TokenPermissions(
+        token=order_data["parameters"]["src_asset"],
+        amount=int(order_data["parameters"]["src_quantity"]),
+    )
+
+    if nonce is None:
+        nonce = get_random_nonce()
+
+    permit_witness = EIP712PermitWitnessTransferFromOrder(
+        permitted=token_permissions,
+        spender=order_data["router_address"],
+        nonce=nonce,
+        deadline=int(order_data["deadline"]),
+        witness=signed_order,
+    )
+
+    typed_data = {
+        "types": {
+            "EIP712Domain": [
+                {"name": "name", "type": "string"},
+                {"name": "chainId", "type": "uint256"},
+                {"name": "verifyingContract", "type": "address"},
+            ],
+            "PermitWitnessTransferFrom": permit_witness.TYPE_STRUCT,
+            "TokenPermissions": token_permissions.TYPE_STRUCT,
+            "SignedOrder": signed_order.TYPE_STRUCT,
+            "OrderParameters": parameters.TYPE_STRUCT,
+        },
+        "primaryType": "PermitWitnessTransferFrom",
+        "domain": domain_data,
+        "message": permit_witness.eip_signable_struct,
+    }
+
+    acct = Account.from_key(private_key)
+    signable = encode_typed_data(full_message=typed_data)
+    sig = acct.sign_message(signable).signature.hex()
+    if not sig.startswith("0x"):
+        sig = "0x" + sig
+
+    return {
+        "signature": sig,
+        "domain": domain_data,
+        "message": permit_witness.eip_signable_struct,
+    }
+
+
+def sign_close_position(
+    chain_id: int,
+    position_id: int,
+    private_key: str,
+    escrow_contract: str,
+    authorized: str,
+    cash_settle: bool = False,
+    fraction_bps: int = 10_000,
+    deadline_seconds: int = 3600,
+    nonce: Optional[int] = None,
+) -> Dict[str, Any]:
+    """
+    Sign a close margin position request using EIP-712.
+    
+    Args:
+        chain_id: Chain ID
+        position_id: Position ID (NFT token ID)
+        private_key: Private key for signing
+        escrow_contract: Escrow contract address
+        authorized: Authorized filler address
+        cash_settle: Whether to cash settle
+        fraction_bps: Fraction to close in basis points (10000 = 100%)
+        deadline_seconds: Deadline in seconds from now
+        nonce: Optional nonce (random if not provided)
+    
+    Returns:
+        Signed close position payload
+    """
+    if not escrow_contract:
+        raise ValueError("escrow_contract is required")
+    if not authorized:
+        raise ValueError("authorized is required")
+
+    if nonce is None:
+        nonce = get_random_nonce()
+
+    deadline = int(time.time()) + int(deadline_seconds)
+
+    close_msg = EIP712CloseWithSwap(
+        positionId=int(position_id),
+        cashSettle=bool(cash_settle),
+        fractionBps=int(fraction_bps),
+        authorized=str(authorized),
+        nonce=int(nonce),
+        deadline=int(deadline),
+    )
+
+    domain_data = get_escrow_domain(chain_id, escrow_contract)
+    types = get_close_with_swap_types()
+
+    typed_data = {
+        "types": types,
+        "primaryType": "CloseWithSwap",
+        "domain": domain_data,
+        "message": {
+            "positionId": close_msg.positionId,
+            "cashSettle": close_msg.cashSettle,
+            "fractionBps": close_msg.fractionBps,
+            "authorized": close_msg.authorized,
+            "nonce": close_msg.nonce,
+            "deadline": close_msg.deadline,
+        },
+    }
+
+    acct = Account.from_key(private_key)
+    signable = encode_typed_data(full_message=typed_data)
+    sig = acct.sign_message(signable).signature.hex()
+    if not sig.startswith("0x"):
+        sig = "0x" + sig
+
+    return {
+        "signature": sig,
+        "domain": domain_data,
+        "message": typed_data["message"],
+        "chainId": str(chain_id),
+    }
+
+
 async def approve_permit2(
     w3: AsyncWeb3[P],
     account: LocalAccount,
-    chain: ChainID,
+    chain: str,
     token_address: str,
     required_quantity: int,
     maxGas: int = 100000,
 ):
     wallet_address = account.address
+    permit2_address = get_permit2_addr(chain)
 
     erc20 = get_erc20_contract(w3, token_address)
-    permit2_contract = _PERMIT2_CONTRACT_ADDRESSES.get(chain)
     current_allowance = await erc20.functions.allowance(
-        wallet_address, permit2_contract
+        wallet_address, permit2_address
     ).call()
     if current_allowance < required_quantity:
         logger.info(
             f"Approving {token_address}: allowance={current_allowance}, required={required_quantity}"
         )
-        approve_fn = erc20.functions.approve(permit2_contract, 2**256 - 1)
+        approve_fn = erc20.functions.approve(permit2_address, 2**256 - 1)
         tx = await approve_fn.build_transaction(
             {
                 "from": wallet_address,
                 "nonce": await w3.eth.get_transaction_count(
                     w3.to_checksum_address(wallet_address)
                 ),
-                "gas": maxGas,  # Adjust as needed
+                "gas": maxGas,
                 "gasPrice": await w3.eth.gas_price,
             }
         )
 
-        # Sign and send transaction
         tx_data = tx if isinstance(tx, dict) else tx.__dict__
         signed_tx: SignedTransaction = account.sign_transaction(tx_data)
         tx_hash = await w3.eth.send_raw_transaction(signed_tx.raw_transaction)
@@ -359,27 +542,46 @@ async def approve_permit2(
         return tx_hash.hex()
 
 
-async def create_order(
+@dataclass
+class Permit2Order:
+    msg: SignatureData
+    sig: SignedMessage
+
+
+async def create_permit2_order(
     w3: AsyncWeb3[P],
     account: LocalAccount,
-    src_chain: ChainID,
+    src_chain: str,
     src_token: str,
-    dst_chain: ChainID,
+    dst_chain: str,
     dst_token: str,
     raw_amount: int,
-    to_address: Optional[str] = None,
-):
-    if not to_address:
-        to_address = account.address
+    dst_address: str | None = None,
+) -> Permit2Order:
+    if not dst_address:
+        dst_address = account.address
     q = await get_quote(
         account.address,
-        to_address,
+        dst_address,
         src_chain,
         src_token,
         dst_chain,
         dst_token,
         raw_amount,
     )
-    await approve_permit2(w3, account, src_chain, src_token, raw_amount)
-    # print("Quote: ", json.dumps(q))
-    return await sign_permit2(w3.eth, account, account.address, raw_amount, q)
+
+    order_type = q.get("orderType") or q.get("order_type")
+    if not order_type:
+        order_data = q.get("order_data")
+        if isinstance(order_data, dict):
+            order_type = order_data.get("order_type") or order_data.get("orderType")
+
+    if not order_type:
+        raise ValueError(f"quote missing order type (keys={sorted(q.keys())})")
+
+    if str(order_type).strip().upper() == "FEATHER":
+        raise Exception("Feather routes unsupported for automatic trades")
+
+    _ = await approve_permit2(w3, account, src_chain, src_token, raw_amount)
+    msg, sig = await sign_permit2(w3.eth, account, account.address, raw_amount, q)
+    return Permit2Order(msg, sig)

tristero-0.3.0.dist-info/METADATA

@@ -0,0 +1,198 @@
+Metadata-Version: 2.4
+Name: tristero
+Version: 0.3.0
+Summary: Library for trading on Tristero
+Author-email: pty1 <pty11@proton.me>
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: certifi>=2023.7.22
+Requires-Dist: eth-account>=0.8.0
+Requires-Dist: glom>=25.12.0
+Requires-Dist: httpx>=0.23.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: tenacity>=8.0.0
+Requires-Dist: web3>=6.0.0
+Requires-Dist: websockets>=10.0
+Dynamic: license-file
+
+# Tristero
+[![PyPI version](https://badge.fury.io/py/tristero.svg)](https://badge.fury.io/py/tristero)
+[![Python Support](https://img.shields.io/pypi/pyversions/tristero.svg)](https://pypi.org/project/tristero/)
+
+This repository is home to Tristero's trading library.
+
+### Installation
+```
+pip install tristero
+```
+
+### Quick Start
+
+Execute a cross-chain swap in just a few lines:
+
+```py
+import os
+import asyncio
+
+from eth_account import Account
+
+from tristero import ChainID, TokenSpec, execute_permit2_swap, make_async_w3
+
+
+async def main() -> None:
+    private_key = os.getenv("TEST_ACCOUNT_PRIVKEY")
+    if not private_key:
+        raise RuntimeError("Set TEST_ACCOUNT_PRIVKEY")
+
+    account = Account.from_key(private_key)
+
+    arbitrum_rpc = os.getenv("ARBITRUM_RPC_URL", "https://arbitrum-one-rpc.publicnode.com")
+    w3 = make_async_w3(arbitrum_rpc)
+
+    # Example: USDC on Arbitrum -> USDT on Base
+    result = await execute_permit2_swap(
+        w3=w3,
+        account=account,
+        src_t=TokenSpec(chain_id=ChainID(42161), token_address="0xaf88d065e77c8cC2239327C5EDb3A432268e5831"),  # USDC (Arbitrum)
+        dst_t=TokenSpec(chain_id=ChainID(8453), token_address="0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2"),  # USDT (Base)
+        raw_amount=1_000_000,  # 1 USDC (6 decimals)
+        timeout=300,
+    )
+    print(result)
+
+
+asyncio.run(main())
+```
+
+### Usage Examples
+
+#### Quote (read-only)
+
+```py
+import asyncio
+import os
+
+from eth_account import Account
+
+from tristero import ChainID, get_quote
+
+
+async def main() -> None:
+    private_key = os.getenv("TEST_ACCOUNT_PRIVKEY")
+    if not private_key:
+        raise RuntimeError("Set TEST_ACCOUNT_PRIVKEY")
+
+    wallet = Account.from_key(private_key).address
+
+    quote = await get_quote(
+        from_wallet=wallet,
+        to_wallet=wallet,
+        from_chain_id=str(ChainID(42161).value),
+        from_address="0xaf88d065e77c8cC2239327C5EDb3A432268e5831",  # USDC (Arbitrum)
+        to_chain_id=str(ChainID(42161).value),
+        to_address="0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",  # WETH (Arbitrum)
+        amount=1_000_000,
+    )
+    print(quote)
+
+
+asyncio.run(main())
+```
+
+#### Margin: Direct Open
+
+```py
+import asyncio
+import os
+
+from eth_account import Account
+from tristero import open_margin_position
+
+
+async def main() -> None:
+    private_key = os.getenv("TEST_ACCOUNT_PRIVKEY", "")
+    if not private_key:
+        raise RuntimeError("Set TEST_ACCOUNT_PRIVKEY")
+
+    wallet = Account.from_key(private_key).address
+
+    chain_id = "42161"
+    quote_currency = "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"  # USDC (Arbitrum)
+    base_currency = "0x82aF49447D8a07e3bd95BD0d56f35241523fBab1"  # WETH (Arbitrum)
+    leverage = 2
+    collateral = "1000000"  # 1 USDC (6 decimals)
+
+    result = await open_margin_position(
+        private_key=private_key,
+        chain_id=chain_id,
+        wallet_address=wallet,
+        quote_currency=quote_currency,
+        base_currency=base_currency,
+        leverage_ratio=leverage,
+        collateral_amount=collateral,
+        wait_for_result=True,
+        timeout=120,
+    )
+    print(result)
+
+
+asyncio.run(main())
+```
+
+#### Margin: List Positions / Close Position
+
+```py
+import asyncio
+import os
+
+from eth_account import Account
+from tristero import close_margin_position, list_margin_positions
+
+
+async def main() -> None:
+    private_key = os.getenv("TEST_ACCOUNT_PRIVKEY", "")
+    if not private_key:
+        raise RuntimeError("Set TEST_ACCOUNT_PRIVKEY")
+
+    wallet = Account.from_key(private_key).address
+    chain_id = "42161"
+
+    positions = await list_margin_positions(wallet)
+    open_pos = next((p for p in positions if p.status == "open"), None)
+    if not open_pos:
+        raise RuntimeError("no open positions")
+
+    result = await close_margin_position(
+        private_key=private_key,
+        chain_id=chain_id,
+        position_id=open_pos.taker_token_id,
+        escrow_contract=open_pos.escrow_address,
+        authorized=open_pos.filler_address,
+        cash_settle=False,
+        fraction_bps=10_000,
+        deadline_seconds=3600,
+        wait_for_result=True,
+        timeout=120,
+    )
+    print(result)
+
+
+asyncio.run(main())
+```
+
+### How it works
+
+Tristero supports two primary swap mechanisms:
+
+#### Permit2 Swaps (EVM-to-EVM)
+- **Quote & Approve** - Request a quote and approve tokens via Permit2 (gasless approval)
+- **Sign & Submit** - Sign an EIP-712 order and submit for execution
+- **Monitor** - Track swap progress via WebSocket updates
+
+#### Feather Swaps (UTXO-based)
+- **Quote & Deposit** - Request a quote to receive a deposit address
+- **Manual Transfer** - Send funds to the provided deposit address
+- **Monitor** - Track swap completion via WebSocket updates
+
+This library provides both high-level convenience functions and lower-level components for precise control.

tristero-0.3.0.dist-info/RECORD

@@ -0,0 +1,22 @@
+tristero/__init__.py,sha256=lKstpKnnzd2PnvI79SwWnOwOMkDla9Nt_HbyrhnV6s0,1854
+tristero/api.py,sha256=DLNYsFj81TId3EfCwlXRfxUws-7lLTkMO1znF9D3abU,7900
+tristero/client.py,sha256=WMPthsJ5Rb6tOkBiHe4533r3Kqcdk_6bvlOPOJEB9HA,19125
+tristero/config.py,sha256=v7ohAv-KbnFpWQbyXYD78QABFTW1vm1P4GkIV2-5uC0,1002
+tristero/data.py,sha256=8Y1865c5tLVHDCwDRjyMlp7xR4KXAej_4yK8WcZCTcU,1512
+tristero/permit2.py,sha256=lYawwcechaxQuEe1QUMd4tR0FBnuNri1Gs0tXdTK_eY,17604
+tristero/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tristero/eip712/__init__.py,sha256=xTsAPEiwYidBaya3py_wMVFH4mOd4Md7hH5eTGFwvSI,1256
+tristero/eip712/eip712_auto.py,sha256=h-AwA8BsIAvZoe3TB8fzlvNKX17ZVG_NwbroqZ_LWl4,7293
+tristero/eip712/eip712_struct.py,sha256=aWBOdsGarQnxONA5hr-DVdlrUD-yvtu_yi3G9DrU9cQ,2286
+tristero/eip712/escrow_utils.py,sha256=EOXpzxJ_29A0yvEloI5sxYe33atMhkoIAV4pkAia92s,869
+tristero/eip712/nested_types.py,sha256=rsB-pZ6K8EeulU__6z0pY_6LHWkjh7N6776ekl9Jcnw,1972
+tristero/eip712/simple_types.py,sha256=9rHqz7XbbdwdOMCKbQr8HGYwPgqC3S6sQbm2I7DbQVM,11865
+tristero/files/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tristero/files/chains.json,sha256=04jFywe_V0wrS0tcjdCUHMxIutaLJ_k5ABbbmkyZ9jY,256150
+tristero/files/erc20_abi.json,sha256=jvsJ6aCwhMcmo3Yy1ajt5lPl_nTRg7tv-tGj87xzTOg,12800
+tristero/files/permit2_abi.json,sha256=NV0AUUA9kqFPk56njvRRzUyjBhrBncKIMd3PrSH0LCc,17817
+tristero-0.3.0.dist-info/licenses/LICENSE,sha256=b-9ikwk9ICk964mtUbqVkDgSf3S6d52HTQxyGHmNo9M,10925
+tristero-0.3.0.dist-info/METADATA,sha256=Z4XmDOqGpCmt21zhOto5VB1FL8Lil8HGDf2GbJA-qQc,5318
+tristero-0.3.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+tristero-0.3.0.dist-info/top_level.txt,sha256=xO745nTllCKw6Fdu-a2ZYv5-ZVOKl2vt9ccRUjCVXfI,9
+tristero-0.3.0.dist-info/RECORD,,

tristero-0.3.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+