// ERC-4626 标准函数
function deposit(uint256 assets, address receiver) external returns (uint256 shares);
// assets = 存入的 USDe 数量（wei）
// receiver = 接收 sUSDe 的地址
// returns = 获得的 sUSDe 数量

function mint(uint256 shares, address receiver) external returns (uint256 assets);
// shares = 想要获得的 sUSDe 数量
// receiver = 接收 sUSDe 的地址
// returns = 需要存入的 USDe 数量

// Ethena 自定义函数 — 启动冷却期
function cooldownAssets(uint256 assets) external returns (uint256 shares);
// assets = 要赎回的 USDe 数量
// 将对应的 sUSDe 锁定并启动 7 天倒计时
// returns = 被锁定的 sUSDe 数量

function cooldownShares(uint256 shares) external returns (uint256 assets);
// shares = 要赎回的 sUSDe 数量
// returns = 到期后可领取的 USDe 数量

function unstake(address receiver) external;
// 冷却期结束后调用，将 USDe 发送给 receiver
// 如果冷却期未结束，交易会 revert

function convertToShares(uint256 assets) external view returns (uint256);
// 查询 X 个 USDe 能换多少 sUSDe

function convertToAssets(uint256 shares) external view returns (uint256);
// 查询 X 个 sUSDe 值多少 USDe

function cooldowns(address owner) external view returns (uint104 cooldownEnd, uint152 underlyingAmount);
// 查询某地址的冷却期状态
// cooldownEnd = UNIX 时间戳（冷却到期时间）
// underlyingAmount = 到期可领取的 USDe 数量

function cooldownDuration() external view returns (uint24);
// 查询当前冷却期时长（秒）。当前 = 604800（7天 = 7 × 86400）

function totalAssets() external view returns (uint256);
// sUSDe 金库持有的总 USDe 数量

function previewDeposit(uint256 assets) external view returns (uint256 shares);
// 预览存入 assets 个 USDe 能得到多少 sUSDe

function previewRedeem(uint256 shares) external view returns (uint256 assets);
// 预览赎回 shares 个 sUSDe 能得到多少 USDe

// 授权 sUSDe 合约花费你的 USDe
function approve(address spender, uint256 amount) external returns (bool);
// spender = sUSDe 合约地址 0x9D39A5DE30e57443BfF2A8307A4256c8797A3497
// amount = 授权金额（建议用 type(uint256).max 做无限授权，或精确数量）

function allowance(address owner, address spender) external view returns (uint256);
// 查询授权额度

function balanceOf(address account) external view returns (uint256);
// 查询余额

# 推荐 Python 3.10+
pip install web3>=6.0.0 python-dotenv requests

# 可选：硬件钱包支持
pip install ledgereth  # Ledger 签名

# 项目结构
tradeSys/
├── ethena/
│   ├── __init__.py
│   ├── config.py          # 合约地址、ABI、RPC 配置
│   ├── contracts.py       # 合约交互封装
│   ├── gas_optimizer.py   # Gas 估算与优化
│   ├── executor.py        # 交易执行与重试
│   ├── monitor.py         # Funding rate 监控
│   └── scheduler.py       # 自动化调度
├── .env                   # 私钥/RPC URL（绝对不入 git）
└── run.py                 # CLI 入口

ETH_RPC_URL=https://eth-mainnet.g.alchemy.com/v2/YOUR_KEY
# 或 Infura: https://mainnet.infura.io/v3/YOUR_KEY
# 免费替代：https://rpc.ankr.com/eth

# ⚠️ 生产环境强烈建议用硬件钱包，不在 .env 存私钥
# 仅用于测试/小额操作
PRIVATE_KEY=0x_YOUR_PRIVATE_KEY_NEVER_COMMIT_THIS

WALLET_ADDRESS=0xYOUR_ADDRESS

"""ethena/config.py - 合约地址与 ABI 配置"""

# === 合约地址（Ethereum Mainnet）===
USDE_ADDRESS = "0x4c9EDD5852cd905f086C759E8383e09bff1E68B3"
SUSDE_ADDRESS = "0x9D39A5DE30e57443BfF2A8307A4256c8797A3497"
USDC_ADDRESS = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"

# === sUSDe (StakedUSDeV2) 关键 ABI ===
SUSDE_ABI = [
    # === Staking ===
    {
        "name": "deposit",
        "type": "function",
        "stateMutability": "nonpayable",
        "inputs": [
            {"name": "assets", "type": "uint256"},
            {"name": "receiver", "type": "address"}
        ],
        "outputs": [{"name": "shares", "type": "uint256"}]
    },
    # === Cooldown（发起解锁）===
    {
        "name": "cooldownAssets",
        "type": "function",
        "stateMutability": "nonpayable",
        "inputs": [{"name": "assets", "type": "uint256"}],
        "outputs": [{"name": "shares", "type": "uint256"}]
    },
    {
        "name": "cooldownShares",
        "type": "function",
        "stateMutability": "nonpayable",
        "inputs": [{"name": "shares", "type": "uint256"}],
        "outputs": [{"name": "assets", "type": "uint256"}]
    },
    # === Claim（领取）===
    {
        "name": "unstake",
        "type": "function",
        "stateMutability": "nonpayable",
        "inputs": [{"name": "receiver", "type": "address"}],
        "outputs": []
    },
    # === 查询 ===
    {
        "name": "convertToShares",
        "type": "function",
        "stateMutability": "view",
        "inputs": [{"name": "assets", "type": "uint256"}],
        "outputs": [{"name": "", "type": "uint256"}]
    },
    {
        "name": "convertToAssets",
        "type": "function",
        "stateMutability": "view",
        "inputs": [{"name": "shares", "type": "uint256"}],
        "outputs": [{"name": "", "type": "uint256"}]
    },
    {
        "name": "cooldowns",
        "type": "function",
        "stateMutability": "view",
        "inputs": [{"name": "owner", "type": "address"}],
        "outputs": [
            {"name": "cooldownEnd", "type": "uint104"},
            {"name": "underlyingAmount", "type": "uint152"}
        ]
    },
    {
        "name": "cooldownDuration",
        "type": "function",
        "stateMutability": "view",
        "inputs": [],
        "outputs": [{"name": "", "type": "uint24"}]
    },
    {
        "name": "totalAssets",
        "type": "function",
        "stateMutability": "view",
        "inputs": [],
        "outputs": [{"name": "", "type": "uint256"}]
    },
    {
        "name": "previewDeposit",
        "type": "function",
        "stateMutability": "view",
        "inputs": [{"name": "assets", "type": "uint256"}],
        "outputs": [{"name": "", "type": "uint256"}]
    },
    {
        "name": "previewRedeem",
        "type": "function",
        "stateMutability": "view",
        "inputs": [{"name": "shares", "type": "uint256"}],
        "outputs": [{"name": "", "type": "uint256"}]
    },
    {
        "name": "balanceOf",
        "type": "function",
        "stateMutability": "view",
        "inputs": [{"name": "account", "type": "address"}],
        "outputs": [{"name": "", "type": "uint256"}]
    },
]

# === USDe ERC-20 ABI（仅需 approve + balanceOf + allowance）===
ERC20_ABI = [
    {
        "name": "approve",
        "type": "function",
        "stateMutability": "nonpayable",
        "inputs": [
            {"name": "spender", "type": "address"},
            {"name": "amount", "type": "uint256"}
        ],
        "outputs": [{"name": "", "type": "bool"}]
    },
    {
        "name": "allowance",
        "type": "function",
        "stateMutability": "view",
        "inputs": [
            {"name": "owner", "type": "address"},
            {"name": "spender", "type": "address"}
        ],
        "outputs": [{"name": "", "type": "uint256"}]
    },
    {
        "name": "balanceOf",
        "type": "function",
        "stateMutability": "view",
        "inputs": [{"name": "account", "type": "address"}],
        "outputs": [{"name": "", "type": "uint256"}]
    },
    {
        "name": "decimals",
        "type": "function",
        "stateMutability": "view",
        "inputs": [],
        "outputs": [{"name": "", "type": "uint8"}]
    },
]

"""stake_usde.py - 将 USDe stake 为 sUSDe"""
import os, time
from web3 import Web3
from dotenv import load_dotenv
from ethena.config import USDE_ADDRESS, SUSDE_ADDRESS, SUSDE_ABI, ERC20_ABI

load_dotenv()
w3 = Web3(Web3.HTTPProvider(os.getenv("ETH_RPC_URL")))
account = w3.eth.account.from_key(os.getenv("PRIVATE_KEY"))

usde = w3.eth.contract(address=USDE_ADDRESS, abi=ERC20_ABI)
susde = w3.eth.contract(address=SUSDE_ADDRESS, abi=SUSDE_ABI)

def stake_usde(amount_usde: float, max_gas_gwei: float = 10.0):
    """
    将指定数量的 USDe stake 为 sUSDe
    
    Args:
        amount_usde: USDe 数量（人类可读，如 12500.0）
        max_gas_gwei: 最大可接受 gas price（gwei），超过则放弃
    """
    amount_wei = int(amount_usde * 10**18)  # USDe 18 decimals
    
    # === Step 0: Gas 检查 ===
    base_fee = w3.eth.get_block('latest')['baseFeePerGas']
    base_fee_gwei = base_fee / 10**9
    if base_fee_gwei > max_gas_gwei:
        print(f"⚠️ Gas too high: {base_fee_gwei:.1f} gwei > {max_gas_gwei} limit. Aborting.")
        return None
    
    # === Step 1: 检查 USDe 余额 ===
    balance = usde.functions.balanceOf(account.address).call()
    assert balance >= amount_wei, f"USDe 余额不足: {balance/10**18:.2f} < {amount_usde}"
    
    # === Step 2: Approve（如果 allowance 不够）===
    allowance = usde.functions.allowance(account.address, SUSDE_ADDRESS).call()
    if allowance < amount_wei:
        print(f"📝 Approving sUSDe contract to spend {amount_usde} USDe...")
        approve_tx = usde.functions.approve(
            SUSDE_ADDRESS, 
            2**256 - 1  # 无限授权（减少未来 Gas 消耗）
        ).build_transaction({
            'from': account.address,
            'nonce': w3.eth.get_transaction_count(account.address),
            'maxFeePerGas': int(base_fee * 2),
            'maxPriorityFeePerGas': w3.to_wei(0.1, 'gwei'),  # 极低 tip
        })
        signed = account.sign_transaction(approve_tx)
        tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
        receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=300)
        assert receipt['status'] == 1, f"Approve failed! tx: {tx_hash.hex()}"
        print(f"✅ Approve success. Gas used: {receipt['gasUsed']}")
    
    # === Step 3: 预览获得的 sUSDe 数量 ===
    shares = susde.functions.previewDeposit(amount_wei).call()
    print(f"📊 预计获得 sUSDe: {shares/10**18:.6f} (汇率: {amount_usde/(shares/10**18):.6f} USDe/sUSDe)")
    
    # === Step 4: Deposit（Stake）===
    print(f"🔄 Staking {amount_usde} USDe → sUSDe...")
    deposit_tx = susde.functions.deposit(
        amount_wei,
        account.address  # receiver = 自己
    ).build_transaction({
        'from': account.address,
        'nonce': w3.eth.get_transaction_count(account.address),
        'maxFeePerGas': int(base_fee * 2),
        'maxPriorityFeePerGas': w3.to_wei(0.1, 'gwei'),
    })
    signed = account.sign_transaction(deposit_tx)
    tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=300)
    
    if receipt['status'] == 1:
        print(f"✅ Stake success! Gas used: {receipt['gasUsed']}")
        print(f"   TX: https://etherscan.io/tx/{tx_hash.hex()}")
        actual_shares = susde.functions.balanceOf(account.address).call()
        print(f"   sUSDe balance: {actual_shares/10**18:.6f}")
    else:
        print(f"❌ Stake FAILED! TX: https://etherscan.io/tx/{tx_hash.hex()}")
    
    return receipt

# === 使用示例 ===
if __name__ == "__main__":
    # $12,500 的 USDe（实际金额以 USDe 计，≈ $12,500）
    stake_usde(amount_usde=12500.0, max_gas_gwei=5.0)

"""unstake_susde.py - 发起 sUSDe cooldown"""
import os, time, datetime
from web3 import Web3
from dotenv import load_dotenv
from ethena.config import SUSDE_ADDRESS, SUSDE_ABI

load_dotenv()
w3 = Web3(Web3.HTTPProvider(os.getenv("ETH_RPC_URL")))
account = w3.eth.account.from_key(os.getenv("PRIVATE_KEY"))
susde = w3.eth.contract(address=SUSDE_ADDRESS, abi=SUSDE_ABI)

def start_cooldown(shares_to_unstake: float = None, unstake_all: bool = False):
    """
    发起 sUSDe cooldown
    
    Args:
        shares_to_unstake: sUSDe 数量。None + unstake_all=True 则全部 unstake
    """
    balance = susde.functions.balanceOf(account.address).call()
    print(f"当前 sUSDe 余额: {balance/10**18:.6f}")
    
    if unstake_all:
        shares_wei = balance
    else:
        shares_wei = int(shares_to_unstake * 10**18)
    
    assert shares_wei > 0 and shares_wei <= balance, "Invalid amount"
    
    # 预览能拿到多少 USDe
    assets = susde.functions.previewRedeem(shares_wei).call()
    print(f"预计到期可领取 USDe: {assets/10**18:.2f}")
    
    # 查询 cooldown 时长
    duration = susde.functions.cooldownDuration().call()
    unlock_time = datetime.datetime.now() + datetime.timedelta(seconds=duration)
    print(f"Cooldown 时长: {duration}s ({duration/86400:.1f} 天)")
    print(f"预计解锁时间: {unlock_time.strftime('%Y-%m-%d %H:%M')}")
    
    # 发起 cooldown
    base_fee = w3.eth.get_block('latest')['baseFeePerGas']
    tx = susde.functions.cooldownShares(shares_wei).build_transaction({
        'from': account.address,
        'nonce': w3.eth.get_transaction_count(account.address),
        'maxFeePerGas': int(base_fee * 2),
        'maxPriorityFeePerGas': w3.to_wei(0.1, 'gwei'),
    })
    signed = account.sign_transaction(tx)
    tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=300)
    
    if receipt['status'] == 1:
        print(f"✅ Cooldown started! Gas: {receipt['gasUsed']}")
        print(f"   TX: https://etherscan.io/tx/{tx_hash.hex()}")
        print(f"   ⏰ 请在 {unlock_time.strftime('%Y-%m-%d %H:%M')} 之后执行 claim")
    else:
        print(f"❌ Cooldown FAILED!")
    
    return receipt

def check_cooldown_status():
    """检查当前 cooldown 状态"""
    cooldown_end, underlying = susde.functions.cooldowns(account.address).call()
    
    if cooldown_end == 0:
        print("没有进行中的 cooldown")
        return None
    
    end_dt = datetime.datetime.fromtimestamp(cooldown_end)
    now = datetime.datetime.now()
    remaining = end_dt - now
    
    print(f"Cooldown 到期: {end_dt.strftime('%Y-%m-%d %H:%M')}")
    print(f"可领取 USDe: {underlying/10**18:.2f}")
    
    if remaining.total_seconds() <= 0:
        print("✅ Cooldown 已结束，可以 claim!")
        return True
    else:
        print(f"⏳ 还需等待: {remaining.days}天 {remaining.seconds//3600}小时")
        return False

if __name__ == "__main__":
    check_cooldown_status()
    # start_cooldown(unstake_all=True)

"""claim_usde.py - cooldown 到期后领取 USDe"""
import os
from web3 import Web3
from dotenv import load_dotenv
from ethena.config import SUSDE_ADDRESS, USDE_ADDRESS, SUSDE_ABI, ERC20_ABI

load_dotenv()
w3 = Web3(Web3.HTTPProvider(os.getenv("ETH_RPC_URL")))
account = w3.eth.account.from_key(os.getenv("PRIVATE_KEY"))
susde = w3.eth.contract(address=SUSDE_ADDRESS, abi=SUSDE_ABI)
usde = w3.eth.contract(address=USDE_ADDRESS, abi=ERC20_ABI)

def claim_usde():
    """cooldown 到期后领取 USDe"""
    # 先检查 cooldown 是否已到期
    cooldown_end, underlying = susde.functions.cooldowns(account.address).call()
    
    import time
    if cooldown_end == 0:
        print("❌ 没有待领取的 cooldown")
        return None
    if time.time() < cooldown_end:
        print(f"❌ Cooldown 未到期，还需 {(cooldown_end - time.time())/3600:.1f} 小时")
        return None
    
    print(f"✅ Cooldown 已到期，领取 {underlying/10**18:.2f} USDe...")
    
    before_balance = usde.functions.balanceOf(account.address).call()
    
    base_fee = w3.eth.get_block('latest')['baseFeePerGas']
    tx = susde.functions.unstake(account.address).build_transaction({
        'from': account.address,
        'nonce': w3.eth.get_transaction_count(account.address),
        'maxFeePerGas': int(base_fee * 2),
        'maxPriorityFeePerGas': w3.to_wei(0.1, 'gwei'),
    })
    signed = account.sign_transaction(tx)
    tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=300)
    
    if receipt['status'] == 1:
        after_balance = usde.functions.balanceOf(account.address).call()
        received = (after_balance - before_balance) / 10**18
        print(f"✅ Claim success! 收到 {received:.2f} USDe")
        print(f"   Gas: {receipt['gasUsed']}")
        print(f"   TX: https://etherscan.io/tx/{tx_hash.hex()}")
    else:
        print(f"❌ Claim FAILED!")
    
    return receipt

if __name__ == "__main__":
    claim_usde()

"""dex_swap.py - USDC ↔ USDe via 1inch API"""
import os, requests, time
from web3 import Web3
from dotenv import load_dotenv

load_dotenv()
w3 = Web3(Web3.HTTPProvider(os.getenv("ETH_RPC_URL")))
account = w3.eth.account.from_key(os.getenv("PRIVATE_KEY"))

USDC = "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
USDE = "0x4c9EDD5852cd905f086C759E8383e09bff1E68B3"

def get_1inch_quote(from_token: str, to_token: str, amount_wei: int) -> dict:
    """从 1inch API 获取报价"""
    url = "https://api.1inch.dev/swap/v6.0/1/quote"
    headers = {"Authorization": "Bearer YOUR_1INCH_API_KEY"}
    params = {
        "src": from_token,
        "dst": to_token,
        "amount": str(amount_wei),
    }
    resp = requests.get(url, headers=headers, params=params)
    return resp.json()

def swap_usdc_to_usde(amount_usdc: float, slippage_pct: float = 0.5):
    """
    USDC → USDe swap via 1inch
    注意：USDC 是 6 decimals，USDe 是 18 decimals
    """
    amount_wei = int(amount_usdc * 10**6)  # USDC = 6 decimals
    
    # Step 1: 获取报价
    quote = get_1inch_quote(USDC, USDE, amount_wei)
    to_amount = int(quote['dstAmount'])
    print(f"报价: {amount_usdc} USDC → {to_amount/10**18:.2f} USDe")
    print(f"汇率: 1 USDC = {to_amount/10**18/amount_usdc:.6f} USDe")
    
    # Step 2: 获取 swap 交易数据
    swap_url = "https://api.1inch.dev/swap/v6.0/1/swap"
    headers = {"Authorization": "Bearer YOUR_1INCH_API_KEY"}
    params = {
        "src": USDC,
        "dst": USDE,
        "amount": str(amount_wei),
        "from": account.address,
        "slippage": str(slippage_pct),
    }
    resp = requests.get(swap_url, headers=headers, params=params)
    swap_data = resp.json()
    
    # Step 3: 需要先 approve USDC 给 1inch router
    # （省略 approve 步骤，与 2.3 类似）
    
    # Step 4: 发送交易
    tx = {
        'from': account.address,
        'to': Web3.to_checksum_address(swap_data['tx']['to']),
        'data': swap_data['tx']['data'],
        'value': int(swap_data['tx']['value']),
        'nonce': w3.eth.get_transaction_count(account.address),
        'maxFeePerGas': int(swap_data['tx'].get('maxFeePerGas', w3.eth.get_block('latest')['baseFeePerGas'] * 2)),
        'maxPriorityFeePerGas': w3.to_wei(0.1, 'gwei'),
        'gas': int(swap_data['tx']['gas']),
    }
    signed = account.sign_transaction(tx)
    tx_hash = w3.eth.send_raw_transaction(signed.raw_transaction)
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=300)
    
    print(f"{'✅' if receipt['status']==1 else '❌'} Swap {'success' if receipt['status']==1 else 'FAILED'}")
    print(f"   Gas: {receipt['gasUsed']}, TX: https://etherscan.io/tx/{tx_hash.hex()}")
    
    return receipt

# === CowSwap 替代方案（MEV 保护，无需 1inch API key）===
# CowSwap SDK: pip install cow-py
# 文档: https://docs.cow.fi/
# 优势：无 MEV + 更好的价格发现 + Ethena dApp 底层用的就是 CowSwap

def get_optimal_gas_params(w3, urgency="low"):
    """
    根据紧急程度返回 EIP-1559 Gas 参数
    
    urgency:
      - "low": 不急，等下一个块也行（省钱）
      - "medium": 希望 1-2 个块内打包
      - "high": 紧急，马上打包
    """
    base_fee = w3.eth.get_block('latest')['baseFeePerGas']
    
    configs = {
        "low": {
            "maxPriorityFeePerGas": w3.to_wei(0.05, 'gwei'),  # 极低 tip
            "maxFeePerGas": int(base_fee * 1.5),  # baseFee 1.5倍
        },
        "medium": {
            "maxPriorityFeePerGas": w3.to_wei(0.1, 'gwei'),
            "maxFeePerGas": int(base_fee * 2),
        },
        "high": {
            "maxPriorityFeePerGas": w3.to_wei(1, 'gwei'),
            "maxFeePerGas": int(base_fee * 3),
        },
    }
    return configs[urgency]

MAX_GAS_GWEI = 10.0  # 超过 10 Gwei 就等待
# 按当前 $2,067 ETH，10 Gwei 下全流程 ~$12，仍远在可接受范围内

"""ledger_signer.py - 硬件钱包签名"""
from web3 import Web3
from ledgereth import create_account, sign_transaction
import os

class LedgerSigner:
    """使用 Ledger 硬件钱包签名交易"""
    
    def __init__(self, derivation_path="44'/60'/0'/0/0"):
        self.derivation_path = derivation_path
        self.account = create_account(derivation_path)
        self.address = self.account.address
        print(f"Ledger connected: {self.address}")
    
    def sign_and_send(self, w3, tx_dict):
        """签名并发送交易"""
        tx_dict['nonce'] = w3.eth.get_transaction_count(self.address)
        signed_tx = sign_transaction(tx_dict, self.derivation_path)
        tx_hash = w3.eth.send_raw_transaction(signed_tx.rawTransaction)
        receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=300)
        return receipt

class NonceManager:
    """线程安全的 nonce 管理器"""
    
    def __init__(self, w3, address):
        self.w3 = w3
        self.address = address
        self._pending_nonce = None
    
    def get_next_nonce(self):
        if self._pending_nonce is None:
            self._pending_nonce = self.w3.eth.get_transaction_count(
                self.address, 'pending'
            )
        else:
            self._pending_nonce += 1
        return self._pending_nonce

def wait_for_confirmation(w3, tx_hash, confirmations=12):
    """等待交易被确认"""
    receipt = w3.eth.wait_for_transaction_receipt(tx_hash, timeout=300)
    if receipt['status'] != 1:
        raise Exception(f"Transaction failed: {tx_hash.hex()}")
    
    initial_block = receipt['blockNumber']
    target_block = initial_block + confirmations
    
    while w3.eth.block_number < target_block:
        time.sleep(12)
    
    return receipt

class TransactionExecutor:
    """带重试机制的交易执行器"""
    
    def __init__(self, w3, max_retries=3, gas_bump=1.3):
        self.w3 = w3
        self.max_retries = max_retries
        self.gas_bump = gas_bump
    
    def execute(self, build_tx, signer, confirmations=3):
        for attempt in range(self.max_retries):
            try:
                tx = build_tx()
                signed = signer.sign_transaction(tx)
                tx_hash = self.w3.eth.send_raw_transaction(signed.raw_transaction)
                receipt = self.w3.eth.wait_for_transaction_receipt(tx_hash, 300)
                if receipt['status'] == 1:
                    return receipt
            except Exception as e:
                if attempt == self.max_retries - 1:
                    raise
                time.sleep(5 * (attempt + 1))

function cooldownDuration() external view returns (uint24);
// 当前返回: 604800

struct UserCooldown {
    uint104 cooldownEnd;      // 冷却到期时间戳（UNIX timestamp）
    uint152 underlyingAmount; // 到期可领取的 USDe 数量
}

mapping(address => UserCooldown) public cooldowns;

# 假设当前 APY 3.49%
apy = 0.0349
cooldown_days = 7
principal = 12500

# 7 天收益损失
opportunity_cost = principal * apy * (cooldown_days / 365)
# = $12,500 × 0.0349 × (7/365)
# = $8.36

print(f"7 天 cooldown 的机会成本: ${opportunity_cost:.2f}")

# Curve 稳定币池滑点估算（简化模型）
def estimate_curve_slippage(amount_in, pool_tvl, A=500):
    """
    amount_in: 交易金额（USD）
    pool_tvl: 池子 TVL（USD）
    A: Curve A 参数
    
    返回: 滑点百分比
    """
    # 简化公式：滑点 ≈ (amount_in / pool_tvl) * (1 / A) * 100
    slippage = (amount_in / pool_tvl) * (1 / A) * 100
    return slippage

# $12,500 交易在 $75M TVL 池子
slippage = estimate_curve_slippage(12500, 75_000_000, A=500)
print(f"Curve 滑点估算: {slippage:.4f}%")  # ≈ 0.0003%

# 加上 0.04% 手续费
total_cost = slippage + 0.04
print(f"总成本: {total_cost:.4f}%")  # ≈ 0.0403%

def exit_strategy(amount_usd, urgency_hours, dex_slippage_pct):
    """
    返回推荐退出策略
    """
    cooldown_cost = 7.3  # Gas ~$0.02 + 机会成本 ~$8.36
    dex_cost = amount_usd * dex_slippage_pct / 100 + 0.02
    
    if urgency_hours < 1:
        return "DEX", dex_cost
    
    if dex_slippage_pct > 0.5:
        return "COOLDOWN", cooldown_cost
    
    # 比较成本
    if dex_cost < cooldown_cost * 0.5:  # DEX 显著更便宜
        return "DEX", dex_cost
    else:
        return "COOLDOWN", cooldown_cost

# 使用
strategy, cost = exit_strategy(12500, urgency_hours=24, dex_slippage_pct=0.04)
print(f"推荐: {strategy}, 预计成本: ${cost:.2f}")

"""monitor_funding.py - 监控 sUSDe APY"""
import requests
from datetime import datetime

class FundingRateMonitor:
    def __init__(self):
        self.thresholds = {
            'susde_to_susds': 0.5,
            'susde_min': 2.0,
        }
    
    def fetch_susde_apy(self):
        """从 DeFiLlama API 获取 sUSDe APY"""
        url = "https://yields.llama.fi/pools"
        try:
            resp = requests.get(url, timeout=30)
            data = resp.json()
            for pool in data['data']:
                if pool.get('symbol') == 'sUSDe' and pool.get('chain') == 'Ethereum':
                    return {'apy': pool.get('apy', 0), 'tvl': pool.get('tvlUsd', 0)}
            return None
        except Exception as e:
            print(f"Error: {e}")
            return None
    
    def check_switch_signal(self):
        susde = self.fetch_susde_apy()
        if not susde:
            return {'action': 'ERROR'}
        
        if susde['apy'] < self.thresholds['susde_min']:
            return {'action': 'URGENT_EXIT', 'apy': susde['apy']}
        
        return {'action': 'HOLD', 'apy': susde['apy']}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "...">
<plist version="1.0">
<dict>
    <key>Label</key>
    <string>com.tradesys.ethena-monitor</string>
    <key>ProgramArguments</key>
    <array>
        <string>/usr/local/bin/python3</string>
        <string>/Users/mac/tradeSys/ethena/monitor_funding.py</string>
    </array>
    <key>StartInterval</key>
    <integer>14400</integer>  <!-- 每4小时 -->
</dict>
</plist>

"""notify.py - 发送告警通知"""
import requests

def send_alert(message: str, webhook_url: str = None):
    """通过 Discord/Slack webhook 发送告警"""
    if webhook_url:
        requests.post(webhook_url, json={"content": message})
    print(f"[ALERT] {message}")

# 使用
if decision['action'] in ['URGENT_EXIT', 'EMERGENCY_EXIT']:
    send_alert(f"⚠️ sUSDe 需要操作: {decision['reason']}")

# 设置每 4 小时自动检查
python monitor_funding.py >> /var/log/ethena_monitor.log