hyperquant 1.41__tar.gz → 1.43__tar.gz

{hyperquant-1.41 → hyperquant-1.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hyperquant
-Version: 1.41
+Version: 1.43
 Summary: A minimal yet hyper-efficient backtesting framework for quantitative trading
 Project-URL: Homepage, https://github.com/yourusername/hyperquant
 Project-URL: Issues, https://github.com/yourusername/hyperquant/issues

{hyperquant-1.41 → hyperquant-1.43}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "hyperquant"
-version = "1.41"
+version = "1.43"
 description = "A minimal yet hyper-efficient backtesting framework for quantitative trading"
 authors = [
     { name = "MissinA", email = "1421329142@qq.com" }

{hyperquant-1.41 → hyperquant-1.43}/src/hyperquant/broker/models/polymarket.py

@@ -225,17 +225,22 @@ class MyTrade(DataStore):
 class Trade(DataStore):
     """User trades keyed by trade id."""
 
-    _KEYS = ["transactionHash"]
+    _KEYS = ["hash"]
     _MAXLEN = 500
 
-
     def _on_message(self, msg: dict[str, Any]) -> None:
         payload = msg or {}
         if payload:
-            size = float(payload.get("size"))
-            price = float(payload.get("price"))
-            # share = size / price
-            # payload['shares'] = share
+            if payload.get("event_type") == "last_trade_price":
+                transaction_hash = payload.get("transaction_hash")
+                if transaction_hash:
+                    payload.update({"hash": transaction_hash})
+                    payload.pop("transaction_hash", None)
+            else:
+                if payload.get("transactionHash"):
+                    payload.update({"hash": payload.get("transactionHash")})
+                    payload.pop("transactionHash", None)
+
             self._insert([payload])
 
 class Book(DataStore):
@@ -861,33 +866,25 @@ class PolymarketDataStore(DataStoreCollection):
         _key asset
         MATCHED进行快速捕捉
         .. code:: json
-            {
-                "asset_id": "52114319501245915516055106046884209969926127482827954674443846427813813222426",
-                "event_type": "trade",
-                "id": "28c4d2eb-bbea-40e7-a9f0-b2fdb56b2c2e",
-                "last_update": "1672290701",
-                "maker_orders": [
-                    {
-                    "asset_id": "52114319501245915516055106046884209969926127482827954674443846427813813222426",
-                    "matched_amount": "10",
-                    "order_id": "0xff354cd7ca7539dfa9c28d90943ab5779a4eac34b9b37a757d7b32bdfb11790b",
-                    "outcome": "YES",
-                    "owner": "9180014b-33c8-9240-a14b-bdca11c0a465",
-                    "price": "0.57"
-                    }
-                ],
-                "market": "0xbd31dc8a20211944f6b70f31557f1001557b59905b7738480ca09bd4532f84af",
-                "matchtime": "1672290701",
-                "outcome": "YES",
-                "owner": "9180014b-33c8-9240-a14b-bdca11c0a465",
-                "price": "0.57",
+           {
+                "asset": "12819879685513143002408869746992985182419696851931617234615358342350852997413",
+                "bio": "",
+                "conditionId": "0xea609d2c6bc2cb20e328be7c89f258b84b35bbe119b44e0a2cfc5f15e6642b3b",
+                "eventSlug": "btc-updown-15m-1763865000",
+                "icon": "https://polymarket-upload.s3.us-east-2.amazonaws.com/BTC+fullsize.png",
+                "name": "infusion",
+                "outcome": "Up",
+                "outcomeIndex": 0,
+                "price": 0.7,
+                "profileImage": "",
+                "proxyWallet": "0x2C060830B6F6B43174b1Cf8B4475db07703c1543",
+                "pseudonym": "Frizzy-Graduate",
                 "side": "BUY",
-                "size": "10",
-                "status": "MATCHED",
-                "taker_order_id": "0x06bc63e346ed4ceddce9efd6b3af37c8f8f440c92fe7da6b2d0f9e4ccbc50c42",
-                "timestamp": "1672290701",
-                "trade_owner": "9180014b-33c8-9240-a14b-bdca11c0a465",
-                "type": "TRADE"
+                "size": 5,
+                "slug": "btc-updown-15m-1763865000",
+                "timestamp": 1763865085,
+                "title": "Bitcoin Up or Down - November 22, 9:30PM-9:45PM ET",
+                "hash": "0xddea11d695e811686f83379d9269accf1be581fbcb542809c6c67a3cc3002488"
             }
         """
         return self._get("trade")
@@ -912,7 +909,7 @@ class PolymarketDataStore(DataStoreCollection):
             elif msg_type == "order":
                 self.orders._on_message(m)
             elif msg_type == "trade":
-                self.trade._on_message(m)
+                self.mytrade._on_message(m)
                 self.fill._on_trade(m)
                 self.position.on_trade(m)
             elif msg_type == 'orders_matched':
@@ -934,3 +931,14 @@ class PolymarketDataStore(DataStoreCollection):
             msg_type = str(raw_type).lower()
             if msg_type in {"book", "price_change"}:
                 self.bbo._on_message(m)
+
+    def onmessage_for_last_trade(self, msg, ws = None):
+        # 判定msg是否为list
+        lst_msg = msg if isinstance(msg, list) else [msg]
+        for m in lst_msg:
+            raw_type = m.get("event_type") or m.get("type")
+            if not raw_type:
+                continue
+            msg_type = str(raw_type).lower()
+            if msg_type == "last_trade_price":
+                self.trade._on_message(m)

{hyperquant-1.41 → hyperquant-1.43}/src/hyperquant/broker/polymarket.py

@@ -35,11 +35,86 @@ ERC20_BALANCE_OF_ABI = (
     "\"name\":\"balanceOf\",\"outputs\":[{\"name\":\"\",\"type\":\"uint256\"}],"
     "\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]"
 )
+CONDITIONAL_TOKENS_ABI = [
+    {
+        "inputs": [
+            {
+                "internalType": "contract IERC20",
+                "name": "collateralToken",
+                "type": "address",
+            },
+            {
+                "internalType": "bytes32",
+                "name": "parentCollectionId",
+                "type": "bytes32",
+            },
+            {
+                "internalType": "bytes32",
+                "name": "conditionId",
+                "type": "bytes32",
+            },
+            {
+                "internalType": "uint256[]",
+                "name": "indexSets",
+                "type": "uint256[]",
+            },
+        ],
+        "name": "redeemPositions",
+        "outputs": [],
+        "stateMutability": "nonpayable",
+        "type": "function",
+    }
+]
 DEFAULT_POLYGON_RPCS = (
     "https://polygon.llamarpc.com",
     "https://polygon-rpc.com",
     "https://rpc.ankr.com/polygon",
 )
+SAFE_ABI = [
+    {
+        "inputs": [],
+        "name": "nonce",
+        "outputs": [{"internalType": "uint256", "name": "nonce", "type": "uint256"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "inputs": [
+            {"internalType": "address", "name": "to", "type": "address"},
+            {"internalType": "uint256", "name": "value", "type": "uint256"},
+            {"internalType": "bytes", "name": "data", "type": "bytes"},
+            {"internalType": "uint8", "name": "operation", "type": "uint8"},
+            {"internalType": "uint256", "name": "safeTxGas", "type": "uint256"},
+            {"internalType": "uint256", "name": "baseGas", "type": "uint256"},
+            {"internalType": "uint256", "name": "gasPrice", "type": "uint256"},
+            {"internalType": "address", "name": "gasToken", "type": "address"},
+            {"internalType": "address", "name": "refundReceiver", "type": "address"},
+            {"internalType": "uint256", "name": "_nonce", "type": "uint256"},
+        ],
+        "name": "getTransactionHash",
+        "outputs": [{"internalType": "bytes32", "name": "txHash", "type": "bytes32"}],
+        "stateMutability": "view",
+        "type": "function",
+    },
+    {
+        "inputs": [
+            {"internalType": "address", "name": "to", "type": "address"},
+            {"internalType": "uint256", "name": "value", "type": "uint256"},
+            {"internalType": "bytes", "name": "data", "type": "bytes"},
+            {"internalType": "uint8", "name": "operation", "type": "uint8"},
+            {"internalType": "uint256", "name": "safeTxGas", "type": "uint256"},
+            {"internalType": "uint256", "name": "baseGas", "type": "uint256"},
+            {"internalType": "uint256", "name": "gasPrice", "type": "uint256"},
+            {"internalType": "address", "name": "gasToken", "type": "address"},
+            {"internalType": "address", "name": "refundReceiver", "type": "address"},
+            {"internalType": "bytes", "name": "signatures", "type": "bytes"},
+        ],
+        "name": "execTransaction",
+        "outputs": [{"internalType": "bool", "name": "success", "type": "bool"}],
+        "stateMutability": "payable",
+        "type": "function",
+    },
+]
 _EASTERN_TZ = pytz.timezone("US/Eastern")
 
 def parse_field(value):
@@ -333,6 +408,7 @@ class Polymarket:
         token_ids: Sequence[str] | str,
         wsapp: pybotters.ws.WebSocketApp | None = None,
         only_bbo: bool = False,
+        with_trades: bool = False
     ) -> pybotters.ws.WebSocketApp:
         """Subscribe to public order-book updates for the provided token ids."""
 
@@ -341,11 +417,14 @@ class Polymarket:
         if wsapp:
             await wsapp.current_ws.send_json(payload)
         hdrl_json = self.store.onmessage_for_bbo if only_bbo else self.store.onmessage
+        hd_lst = [hdrl_json]
+        if with_trades:
+            hd_lst.append(self.store.onmessage_for_last_trade)
 
         self._ws_public = self.client.ws_connect(
             self.ws_public,
             send_json=payload,
-            hdlr_json=hdrl_json,
+            hdlr_json=hd_lst
         )
         await self._ws_public._event.wait()
         return self._ws_public
@@ -388,7 +467,7 @@ class Polymarket:
         return self._ws_personal
     
     async def sub_trades(self, slug: str):
-
+        """订阅activate trades"""
         payload = {
             "action": "subscribe",
             "subscriptions": [
@@ -420,7 +499,10 @@ class Polymarket:
         await wsapp._event.wait()
         await wsapp.current_ws.send_json(payload)
         return wsapp
-        
+    
+
+   
+
     # ------------------------------------------------------------------
     # Public REST endpoints
 
@@ -1239,6 +1321,112 @@ class Polymarket:
             position = position / 1e6
         return position
 
+    async def claim_positions(
+        self,
+        *,
+        user: str | None = None,
+        dry_run: bool = False,
+        rpc_url: str | None = None,
+        rpc_urls: Sequence[str] | None = None,
+        gas: int = 300000,
+        verbose: bool = False,
+        limit: int = 500,
+        include_receipt: bool = False,
+    ) -> list[dict[str, Any]]:
+        """自动拉取 data-api 的 redeemable 头寸并逐个 claim。
+
+        只对满足 redeemable==True 且 curPrice==1 且 size>0 的仓位执行，index_set=1<<outcomeIndex。
+        始终使用 Safe 方式执行 redeemPositions（owner 私钥签名）。
+        """
+        # 默认用代理钱包/资金钱包
+        if user is None:
+            entry = self._api_entry()
+            user = entry[2] if entry and len(entry) > 2 else None
+        if not user:
+            raise RuntimeError("Polymarket claim_positions 需要提供 user (proxy wallet)")
+        if not self.funder:
+            self.funder = user
+
+        # 构造候选 RPC 列表 (单个 rpc_url 优先, 其次用户传入 rpc_urls, 最后内置默认)
+        candidates: list[str] = []
+        if rpc_url:
+            candidates.append(rpc_url)
+        for u in (rpc_urls or []):
+            if u and u not in candidates:
+                candidates.append(u)
+        for u in DEFAULT_POLYGON_RPCS:
+            if u not in candidates:
+                candidates.append(u)
+
+        params = {"user": user, "limit": limit}
+        positions = await self._rest(
+            "GET",
+            "/positions",
+            params=params,
+            host=DEFAULT_DATA_ENDPOINT,
+        )
+
+        claimable: list[dict[str, Any]] = []
+        for pos in positions or []:
+            try:
+                size = float(pos.get("size", 0) or 0)
+            except Exception:
+                size = 0.0
+            redeemable = bool(pos.get("redeemable"))
+            try:
+                cur_price = float(pos.get("curPrice", 0) or 0)
+            except Exception:
+                cur_price = 0.0
+
+            condition_id = pos.get("conditionId")
+            outcome_idx = pos.get("outcomeIndex") or pos.get("outcome_index") or 0
+            if (
+                not condition_id
+                or not redeemable
+                or size <= 0
+                or cur_price != 1
+            ):
+                continue
+            try:
+                idx_set = 1 << int(outcome_idx)
+            except Exception:
+                idx_set = 1
+            claimable.append(
+                {
+                    "condition_id": condition_id,
+                    "index_sets": [idx_set],
+                    "size": size,
+                    "outcome": pos.get("outcome"),
+                    "title": pos.get("title"),
+                }
+            )
+
+        results: list[dict[str, Any]] = []
+        for item in claimable:
+            if dry_run:
+                results.append({**item, "tx": None, "dry_run": True})
+                continue
+            tx_hash = await asyncio.to_thread(
+                self._claim_via_safe_sync,
+                candidates,
+                item["condition_id"],
+                item["index_sets"],
+                gas,
+                verbose,
+            )
+            result_row = {**item, "tx": tx_hash, "dry_run": False}
+            if include_receipt:
+                try:
+                    receipt_info = await self.decode_claim_receipt(
+                        tx_hash,
+                        rpc_url=rpc_url or (rpc_urls[0] if rpc_urls else None),
+                    )
+                    result_row.update({"receipt": receipt_info})
+                except Exception as exc:  # pragma: no cover - 辅助信息获取失败
+                    result_row.update({"receipt_error": str(exc)})
+            results.append(result_row)
+        return results
+
     async def get_usdc_web3(
         self,
         wallet: str = None,
@@ -1279,6 +1467,189 @@ class Polymarket:
     # ------------------------------------------------------------------
     # Internal utilities
 
+    async def decode_claim_receipt(
+        self,
+        tx_hash: str,
+        *,
+        rpc_url: str | None = None,
+    ) -> dict[str, Any]:
+        if not tx_hash:
+            raise ValueError("tx_hash is required")
+        url = rpc_url or DEFAULT_POLYGON_RPCS[0]
+        return await asyncio.to_thread(self._decode_payout_receipt_sync, tx_hash, url)
+
+    def _decode_payout_receipt_sync(self, tx_hash: str, rpc_url: str) -> dict[str, Any]:
+        w3 = _get_web3(rpc_url)
+        receipt = w3.eth.get_transaction_receipt(tx_hash)
+        contract_cfg = self._contracts(self.chain_id, False)
+        ctf_addr = w3.to_checksum_address(contract_cfg["conditional_tokens"])
+        ctf = w3.eth.contract(address=ctf_addr, abi=CONDITIONAL_TOKENS_ABI)
+
+        decoded = []
+        try:
+            decoded = ctf.events.PayoutRedemption().process_receipt(receipt)
+        except Exception:
+            decoded = []
+
+        if decoded:
+            ev = decoded[0]["args"]
+            index_sets = [int(x) for x in ev.get("indexSets", [])]
+            payout = int(ev.get("payout", 0))
+            return {
+                "status": receipt.status,
+                "gasUsed": receipt.gasUsed,
+                "indexSets": index_sets,
+                "payout": payout,
+                "redeemer": ev.get("redeemer"),
+                "collateralToken": ev.get("collateralToken"),
+                "conditionId": ev.get("conditionId").hex()
+                if hasattr(ev.get("conditionId"), "hex")
+                else ev.get("conditionId"),
+            }
+
+        return {"status": receipt.status, "gasUsed": receipt.gasUsed}
+
+    def _claim_via_safe_sync(
+        self,
+        rpc_urls: Sequence[str],
+        condition_id: str,
+        index_sets: list[int],
+        gas: int,
+        verbose: bool = False,
+    ) -> str:
+        from eth_account import Account as _A
+        from time import sleep
+
+        private_key, _, signer_addr = self._get_signing_context()
+        safe_addr = self.funder
+        if not safe_addr:
+            raise RuntimeError("Safe/proxy wallet address未知, 请在 apis['polymarket'][2] 或构造函数 funder 设置")
+
+        w3 = None
+        last_error: Exception | None = None
+        for url in rpc_urls:
+            try:
+                w3 = _get_web3(url)
+                break
+            except Exception as exc:
+                last_error = exc
+                continue
+        if w3 is None:
+            raise RuntimeError(f"All RPC endpoints failed: {rpc_urls}") from last_error
+
+        ctf_addr = self._contracts(self.chain_id, False)["conditional_tokens"]
+        ctf = w3.eth.contract(address=w3.to_checksum_address(ctf_addr), abi=CONDITIONAL_TOKENS_ABI)
+        safe = w3.eth.contract(address=w3.to_checksum_address(safe_addr), abi=SAFE_ABI)
+
+        cond_bytes = bytes.fromhex(condition_id.replace("0x", ""))
+        if len(cond_bytes) != 32:
+            raise ValueError("condition_id must be 32-byte hex string")
+
+        redeem_calldata = ctf.encode_abi(
+            "redeemPositions",
+            args=[
+                w3.to_checksum_address(USDC_CONTRACT),
+                bytes(32),
+                cond_bytes,
+                index_sets,
+            ],
+        )
+
+        safe_tx_gas = 0
+        base_gas = 0
+        gas_price = 0
+        gas_token = ZERO_ADDRESS
+        refund_receiver = ZERO_ADDRESS
+        value = 0
+        operation = 0  # CALL
+
+        try:
+            safe_nonce = safe.functions.nonce().call()
+        except Exception as exc:
+            raise RuntimeError("无法获取 Safe nonce, 请确认 funder 地址为有效 Safe") from exc
+
+        try:
+            safe_tx_hash = safe.functions.getTransactionHash(
+                w3.to_checksum_address(ctf_addr),
+                value,
+                redeem_calldata,
+                operation,
+                safe_tx_gas,
+                base_gas,
+                gas_price,
+                w3.to_checksum_address(gas_token),
+                w3.to_checksum_address(refund_receiver),
+                safe_nonce,
+            ).call()
+        except Exception as exc:
+            raise RuntimeError("Safe getTransactionHash 调用失败") from exc
+
+        signed = _A._sign_hash(safe_tx_hash, private_key)  # eth_sign 风格
+        sig_bytes = (
+            int(signed.r).to_bytes(32, "big")
+            + int(signed.s).to_bytes(32, "big")
+            + bytes([signed.v])
+        )
+
+        try:
+            acct = _A.from_key(private_key)
+            sender = acct.address
+            nonce = w3.eth.get_transaction_count(sender)
+            gas_price_chain = w3.eth.gas_price
+        except Exception as exc:
+            raise RuntimeError("获取 sender nonce/gas_price 失败") from exc
+
+        tx = safe.functions.execTransaction(
+            w3.to_checksum_address(ctf_addr),
+            value,
+            redeem_calldata,
+            operation,
+            safe_tx_gas,
+            base_gas,
+            gas_price,
+            w3.to_checksum_address(gas_token),
+            w3.to_checksum_address(refund_receiver),
+            sig_bytes,
+        ).build_transaction(
+            {
+                "from": sender,
+                "nonce": nonce,
+                "gas": gas,
+                "gasPrice": gas_price_chain,
+            }
+        )
+
+        signed_tx = w3.eth.account.sign_transaction(tx, private_key)
+        send_errors: list[str] = []
+        for attempt in range(3):
+            try:
+                raw_tx = getattr(signed_tx, "rawTransaction", None) or getattr(signed_tx, "raw_transaction", None)
+                if raw_tx is None:  # pragma: no cover
+                    raise AttributeError("Signed transaction missing rawTransaction/raw_transaction")
+                tx_hash = w3.eth.send_raw_transaction(raw_tx)
+                receipt = w3.eth.wait_for_transaction_receipt(tx_hash)
+                if receipt.get("status") != 1:
+                    raise RuntimeError(f"Safe redeemPositions failed status!=1: {tx_hash.hex()}")
+                if verbose:
+                    print(
+                        {
+                            "tx": tx_hash.hex(),
+                            "safe_nonce": safe_nonce,
+                            "wallet": sender,
+                            "gasPrice": gas_price_chain,
+                            "gas": gas,
+                            "rpc_used": getattr(w3.provider, "endpoint_uri", "unknown"),
+                        }
+                    )
+                return tx_hash.hex()
+            except Exception as exc:
+                send_errors.append(str(exc))
+                if verbose:
+                    print(f"Safe redeem attempt {attempt+1} failed: {exc}")
+                sleep(0.5)
+                continue
+        raise RuntimeError(f"Safe redeem all attempts failed: {' | '.join(send_errors)}")
+
     async def _fetch_event(self, slug: str) -> dict | None:
         resp = await self.client.get(GAMMA_EVENTS_API, params={"slug": slug})
         payload = await resp.json()
@@ -1563,11 +1934,33 @@ class Polymarket:
         return [pk, "", (api_key, api_secret, passphrase, chain_id, wallet_address)]
 
 @lru_cache(maxsize=8)
-def _get_web3(rpc_url: str):
+def _get_web3(rpc_url: str | None):
+    """创建 web3 对象, 带多 RPC 备用与重试.
+
+    逻辑:
+    1. 优先使用传入 rpc_url (如果提供)
+    2. 失败则按 DEFAULT_POLYGON_RPCS 顺序依次尝试
+    3. 任一连接成功立即返回, 全部失败抛出统一异常
+    """
     from web3 import Web3
 
-    provider = Web3.HTTPProvider(rpc_url, request_kwargs={"timeout": 10})
-    w3 = Web3(provider)
-    if not w3.is_connected():
-        raise RuntimeError(f"Failed to connect Polygon RPC: {rpc_url}")
-    return w3
+    candidates: list[str] = []
+    if rpc_url:
+        candidates.append(rpc_url)
+    for u in DEFAULT_POLYGON_RPCS:
+        if u not in candidates:
+            candidates.append(u)
+
+    last_error: Exception | None = None
+    for url in candidates:
+        try:
+            provider = Web3.HTTPProvider(url, request_kwargs={"timeout": 7})
+            w3 = Web3(provider)
+            if w3.is_connected():
+                return w3
+            last_error = RuntimeError(f"RPC not connected: {url}")
+        except Exception as exc:  # pragma: no cover - 网络异常
+            last_error = exc
+            continue
+
+    raise RuntimeError(f"Failed to connect Polygon RPCs: {candidates}") from last_error

{hyperquant-1.41 → hyperquant-1.43}/uv.lock

@@ -945,7 +945,7 @@ wheels = [
 
 [[package]]
 name = "hyperquant"
-version = "1.4"
+version = "1.42"
 source = { editable = "." }
 dependencies = [
     { name = "aiohttp" },