tristero 0.1.4__py3-none-any.whl

tristero/permit2.py

@@ -0,0 +1,384 @@
+import logging
+from typing import Any, List, Optional, TypeVar, cast
+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 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 .api import (
+    _WRAPPED_GAS_ADDRESSES,
+    get_quote,
+    _PERMIT2_CONTRACT_ADDRESSES,
+    ChainID,
+)
+
+logger = logging.getLogger(__name__)
+
+P = TypeVar("P", bound=AsyncBaseProvider)
+
+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):
+    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."""
+    return w3.eth.contract(
+        address=Web3.to_checksum_address(token_address), abi=ERC20_ABI
+    )
+
+
+class BaseSchema(BaseModel, frozen=True):
+    model_config = ConfigDict(alias_generator=to_camel, populate_by_name=True)
+
+
+class TokenData(BaseSchema, frozen=True):
+    address: str
+    value: int
+
+
+class ChainData(BaseSchema, frozen=True):
+    chain_id: int
+    token: TokenData
+
+
+class OrderParameters(BaseSchema, frozen=True):
+    src_asset: str
+    dst_asset: str
+    src_quantity: str
+    dst_quantity: str
+    min_quantity: str
+    dark_salt: str
+
+
+class OrderData(BaseSchema, frozen=True):
+    parameters: OrderParameters
+    deadline: int
+    router_address: str
+    filler_wallet_address: str
+    order_type: str
+    custom_data: List[bytes] = Field(default_factory=list)
+
+
+class Quote(BaseSchema, frozen=True):
+    order_data: OrderData
+
+
+class SignedOrder(BaseSchema, frozen=True):
+    sender: str
+    parameters: OrderParameters
+    deadline: str
+    target: str
+    filler: str
+    order_type: str
+    custom_data: List[bytes]
+
+
+class TokenPermissions(BaseSchema, frozen=True):
+    token: str
+    amount: str
+
+
+class EIP712Domain(BaseSchema, frozen=True):
+    name: str
+    chain_id: int
+    verifying_contract: str
+
+
+class PermitMessage(BaseSchema, frozen=True):
+    permitted: TokenPermissions
+    spender: str
+    nonce: str
+    deadline: str
+    witness: SignedOrder
+
+
+class SignatureData(BaseSchema, frozen=True):
+    domain: EIP712Domain
+    types: dict[str, Any]
+    primary_type: str
+    message: PermitMessage
+
+
+def first_zero_bit(n: int) -> int | None:
+    if n > 0 and (n & (n + 1)) == 0:
+        return None
+    return (n ^ (n + 1)).bit_length() - 1
+
+
+async def get_permit2_unordered_nonce(c: AsyncContract, wallet_address: str):
+    startWord = random.randint(2**126, 2**189)
+    endWord = startWord + 10
+    wordPos = await anext(
+        (
+            ((w << 8) | bit)
+            for w in range(startWord, endWord)
+            if (
+                bit := first_zero_bit(
+                    await c.functions.nonceBitmap(wallet_address, w).call()
+                )
+            )
+            is not None
+        ),
+        None,
+    )
+    if wordPos is None:
+        raise Exception(f"No free unordered nonces in words {startWord}-{endWord}")
+    return wordPos
+
+
+async def prepare_data_for_signature(
+    eth: AsyncEth,
+    sell_data: ChainData,
+    buy_data: ChainData,
+    wallet_address: str,
+    quote: Quote,
+    destination_address: str | None = None,
+) -> SignatureData:
+    """
+    Prepare EIP-712 signature data for Permit2 witness transfer.
+
+    Args:
+        sell_data: Source chain and token data
+        buy_data: Destination chain and token data
+        wallet_address: User's wallet address
+        quote: Quote data with order parameters and deadline
+        destination_address: Optional destination address
+
+    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")
+
+    if not quote.order_data.router_address:
+        raise ValueError("Router address is required in the order_data")
+
+    if not quote.order_data.deadline:
+        raise ValueError("Deadline is required in the order_data")
+
+    from_chain = ChainID(str(sell_data.chain_id))
+
+    deadline = quote.order_data.deadline
+
+    # Handle native token address conversion
+    token_address = (
+        _WRAPPED_GAS_ADDRESSES[from_chain]
+        if sell_data.token.address == "native"
+        else sell_data.token.address
+    )
+
+    # Build witness object
+    witness = SignedOrder(
+        sender=wallet_address,
+        parameters=OrderParameters(
+            src_asset=token_address,
+            dst_asset=buy_data.token.address,
+            src_quantity=str(sell_data.token.value),
+            dst_quantity=str(buy_data.token.value),
+            min_quantity=quote.order_data.parameters.min_quantity,
+            dark_salt=quote.order_data.parameters.dark_salt,
+        ),
+        deadline=str(deadline),
+        target=destination_address or wallet_address,
+        filler=quote.order_data.filler_wallet_address,
+        order_type=quote.order_data.order_type,
+        custom_data=quote.order_data.custom_data or [],
+    )
+
+    # Get Permit2 address
+    permit2_address = _PERMIT2_CONTRACT_ADDRESSES.get(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
+    )
+
+    # 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"},
+            {"name": "amount", "type": "uint256"},
+        ],
+        "OrderParameters": [
+            {"name": "srcAsset", "type": "address"},
+            {"name": "dstAsset", "type": "address"},
+            {"name": "srcQuantity", "type": "uint256"},
+            {"name": "dstQuantity", "type": "uint256"},
+            {"name": "minQuantity", "type": "uint256"},
+            {"name": "darkSalt", "type": "uint128"},
+        ],
+        "SignedOrder": [
+            {"name": "sender", "type": "address"},
+            {"name": "parameters", "type": "OrderParameters"},
+            {"name": "deadline", "type": "uint256"},
+            {"name": "target", "type": "address"},
+            {"name": "filler", "type": "address"},
+            {"name": "orderType", "type": "string"},
+            {"name": "customData", "type": "bytes[]"},
+        ],
+        "PermitWitnessTransferFrom": [
+            {"name": "permitted", "type": "TokenPermissions"},
+            {"name": "spender", "type": "address"},
+            {"name": "nonce", "type": "uint256"},
+            {"name": "deadline", "type": "uint256"},
+            {"name": "witness", "type": "SignedOrder"},
+        ],
+    }
+
+    # Build message
+    message = PermitMessage(
+        permitted=TokenPermissions(
+            token=token_address,
+            amount=str(sell_data.token.value),
+        ),
+        spender=spender,
+        nonce=str(nonce),
+        deadline=str(deadline),
+        witness=witness,
+    )
+
+    return SignatureData(
+        domain=domain,
+        types=types,
+        primary_type="PermitWitnessTransferFrom",
+        message=message,
+    )
+
+
+async def sign_permit2(
+    eth: AsyncEth,
+    account: LocalAccount,
+    wallet_address: str,
+    src_amount: int,
+    quote_data: dict[str, Any],
+) -> tuple[SignatureData, SignedMessage]:
+    from_chain_id = quote_data["src_token"]["chain_id"]
+    from_address = quote_data["src_token"]["address"]
+    to_chain_id = quote_data["dst_token"]["chain_id"]
+    to_address = quote_data["dst_token"]["address"]
+
+    order_data = quote_data["order_data"]
+    dst_amount = int(order_data["parameters"]["dst_quantity"])
+
+    to_sign = await prepare_data_for_signature(
+        eth,
+        ChainData(
+            chain_id=from_chain_id,
+            token=TokenData(address=from_address, value=src_amount),
+        ),
+        ChainData(
+            chain_id=to_chain_id,
+            token=TokenData(address=to_address, value=dst_amount),
+        ),
+        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)
+
+
+async def approve_permit2(
+    w3: AsyncWeb3[P],
+    account: LocalAccount,
+    chain: ChainID,
+    token_address: str,
+    required_quantity: int,
+    maxGas: int = 100000,
+):
+    wallet_address = account.address
+
+    erc20 = get_erc20_contract(w3, token_address)
+    permit2_contract = _PERMIT2_CONTRACT_ADDRESSES.get(chain)
+    current_allowance = await erc20.functions.allowance(
+        wallet_address, permit2_contract
+    ).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)
+        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
+                "gasPrice": await w3.eth.gas_price,
+            }
+        )
+
+        # Sign and send transaction
+        signed_tx: SignedTransaction = account.sign_transaction(tx.__dict__)
+        tx_hash = await w3.eth.send_raw_transaction(signed_tx.raw_transaction)
+
+        logger.debug(f"→ Approval tx hash: {tx_hash.hex()}")
+        return tx_hash.hex()
+
+
+async def create_order(
+    w3: AsyncWeb3[P],
+    account: LocalAccount,
+    src_chain: ChainID,
+    src_token: str,
+    dst_chain: ChainID,
+    dst_token: str,
+    raw_amount: int,
+    to_address: str | None = None,
+):
+    if not to_address:
+        to_address = account.address
+    q = await get_quote(
+        account.address,
+        to_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)

tristero-0.1.4.dist-info/METADATA

@@ -0,0 +1,157 @@
+Metadata-Version: 2.3
+Name: tristero
+Version: 0.1.4
+Summary: Library for trading on Tristero
+Author: pty1
+Author-email: pty1 <pty11@proton.me>
+Requires-Dist: eth-account>=0.13.7
+Requires-Dist: httpx>=0.28.1
+Requires-Dist: pydantic>=2.12.4
+Requires-Dist: tenacity>=9.1.2
+Requires-Dist: web3>=7.14.0
+Requires-Dist: websockets>=15.0.1
+Requires-Python: >=3.13
+Description-Content-Type: text/markdown
+
+# 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
+from tristero.client import TokenSpec, execute_swap
+from eth_account import Account
+from web3 import AsyncWeb3
+from tristero.api import ChainID
+
+private_key = os.getenv("EVM_PRIVATE_KEY")
+account = Account.from_key(private_key)
+w3 = AsyncWeb3(AsyncWeb3.AsyncHTTPProvider("https://arbitrum-one-rpc.publicnode.com"))
+
+result = await execute_swap(
+    w3=w3,
+    account=account,
+    src_t=TokenSpec(chain_id=ChainID.arbitrum, token_address="0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9"),  # USDT
+    dst_t=TokenSpec(chain_id=ChainID.base, token_address="0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913"),  # USDC
+    raw_amount=10000000  # Raw token amount (multiply by 10^decimals)
+)
+```
+
+### How it works
+
+Tristero swaps happen in two steps:
+- **Quote & Sign** - Request a quote from the server and sign it with your private key
+- **Submit & Fill** - Submit the signed order to be filled at a later date
+
+This library provides both high-level convenience functions and lower-level components for precise control.
+
+### API Reference
+
+#### Execute Full Swap
+`execute_swap` handles the entire workflow automatically: quoting, signing, submitting, and monitoring.
+```py
+from tristero.swap import execute_swap, TokenSpec
+from web3 import AsyncWeb3
+from eth_account.signers.local import LocalAccount
+
+w3 = AsyncWeb3(...)  # Your Web3 provider
+account: LocalAccount = ...  # Your account
+
+result = await execute_swap(
+    w3=w3,
+    account=account,
+    src_t=TokenSpec(chain_id=ChainID.ethereum, token_address="0xA0b8..."),
+    dst_t=TokenSpec(chain_id=ChainID.arbitrum, token_address="0xaf88..."),
+    raw_amount=10*(10**18),
+    retry=True,
+    timeout=300.0  # 5 minutes
+)
+```
+
+#### Requesting a quote
+
+`get_quote` requests a quote for a particular swap, letting you see output amounts and gas fees.
+
+```py
+from tristero.api import get_quote, ChainID
+
+quote = await get_quote(
+    from_wallet="0x1234...",           # Source wallet address
+    to_wallet="0x5678...",             # Destination wallet address
+    from_chain_id=ChainID.ethereum,    # Source chain
+    from_address="0xA0b8...",          # Source token address (or "native")
+    to_chain_id=ChainID.arbitrum,      # Destination chain
+    to_address="0xaf88...",            # Destination token address (or "native")
+    amount=10*(10**18),                # Amount in smallest unit (wei)
+)
+```
+
+#### Creating a signed order
+`create_order` creates and signs an order without submitting to be filled.
+
+```py
+from tristero.api import get_quote, ChainID
+
+w3 = AsyncWeb3(...)  # Your Web3 provider
+account: LocalAccount = ...  # Your account
+
+data, sig = await create_order(
+    w3,
+    account,
+    from_chain_id=ChainID.ethereum,
+    from_address="0xA0b8...",
+    to_chain_id=ChainID.arbitrum,
+    to_address="0xaf88...",
+    raw_amount=10*(10**18),
+)
+
+```
+
+#### Submit order
+
+`fill_order` submits a signed order for execution.
+
+```py
+from tristero.api import fill_order
+
+data, sig = ... # from earlier
+
+response = await fill_order(
+    signature=str(sig.signature.to_0x_hex()),
+    domain=data.domain.model_dump(by_alias=True, mode="json"),
+    message=data.message.model_dump(by_alias=True, mode="json"),
+)
+
+order_id = response['id']
+```
+
+#### Subscribing for updates
+
+Orders can be monitored for changes and status live
+
+```py
+from tristero.api import poll_updates
+import json
+
+ws = await poll_updates(order_id)
+
+async for msg in ws:
+    update = json.loads(msg)
+    print(f"Completed: {update['completed']}")
+    print(f"Failed: {update['failed']}")
+
+    if update["completed"] or update["failed"]:
+        await ws.close()
+        break
+```

tristero-0.1.4.dist-info/RECORD

@@ -0,0 +1,11 @@
+tristero/__init__.py,sha256=Jmbdg3LwOD4rrO0eerQTmn-wO-Sr4xRZ2r_RtM4iNDg,315
+tristero/api.py,sha256=l4Qk_MJnu77bOjiqIdS7DYQbAg-JvYWBYpSmpeyFXEU,5507
+tristero/client.py,sha256=DEcupVyEbPf78JDu-FrG8a60JlNQM0B10BsfieH8ddE,4073
+tristero/config.py,sha256=_0PP2gufvq_t-gdKqDrxht2BxoWpNiGXk4m_u57WOYY,530
+tristero/files/erc20_abi.json,sha256=jvsJ6aCwhMcmo3Yy1ajt5lPl_nTRg7tv-tGj87xzTOg,12800
+tristero/files/permit2_abi.json,sha256=NV0AUUA9kqFPk56njvRRzUyjBhrBncKIMd3PrSH0LCc,17817
+tristero/permit2.py,sha256=pOqNNZjd78QTHxhAPXjyN5NxBbXd5hF4o0pWP8WDvco,11329
+tristero/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+tristero-0.1.4.dist-info/WHEEL,sha256=eh7sammvW2TypMMMGKgsM83HyA_3qQ5Lgg3ynoecH3M,79
+tristero-0.1.4.dist-info/METADATA,sha256=WSV-y4KXNWNea8NHCUw2geHBDyUjkWBAwKgVp_NodYE,4389
+tristero-0.1.4.dist-info/RECORD,,

tristero-0.1.4.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.8.24
+Root-Is-Purelib: true
+Tag: py3-none-any