poly-web3 0.0.5__py3-none-any.whl → 1.0.0__py3-none-any.whl

poly_web3/log.py

@@ -9,15 +9,17 @@ import sys
 
 LOGGER_NAME = "poly_web3"
 
-logger = logging.getLogger(LOGGER_NAME)
-logger.addHandler(logging.NullHandler())
-
 
 def configure_logging(
         level: int = logging.INFO,
         stream=sys.stdout,
         formatter: logging.Formatter | None = None,
 ):
+    try:
+        from loguru import logger
+        return logger
+    except:
+        pass
     if formatter is None:
         formatter = logging.Formatter(
             "%(asctime)s | %(levelname)s | %(name)s | %(filename)s:%(lineno)d  %(message)s",
@@ -34,15 +36,4 @@ def configure_logging(
     return target
 
 
-def _ensure_default_logging():
-    target = logging.getLogger(LOGGER_NAME)
-    if target.handlers and not all(
-        isinstance(h, logging.NullHandler) for h in target.handlers
-    ):
-        return
-    if logging.getLogger().handlers:
-        return
-    configure_logging()
-
-
-_ensure_default_logging()
+logger = configure_logging()

poly_web3/web3_service/base.py

@@ -4,10 +4,12 @@
 # @Site:
 # @File: base.py
 # @Software: PyCharm
-import requests
+from typing import Any
+
 from py_builder_relayer_client.client import RelayClient
 from py_clob_client.client import ClobClient
 from web3 import Web3
+import requests
 
 from poly_web3.const import (
     RPC_URL,
@@ -166,6 +168,107 @@ class BaseWeb3Service:
             redeem_amounts,
         )._encode_transaction_data()
 
+    def _build_redeem_tx(self, to: str, data: str) -> Any:
+        raise NotImplementedError("redeem tx builder not implemented")
+
+    def _build_redeem_txs_from_positions(self, positions: list[dict]) -> list[Any]:
+        neg_amounts_by_condition: dict[str, list[float]] = {}
+        normal_conditions: set[str] = set()
+        for pos in positions:
+            condition_id = pos.get("conditionId")
+            if not condition_id:
+                continue
+            if pos.get("negativeRisk"):
+                idx = pos.get("outcomeIndex")
+                size = pos.get("size")
+                if idx is None or size is None:
+                    continue
+                amounts = neg_amounts_by_condition.setdefault(condition_id, [0.0, 0.0])
+                if idx not in (0, 1):
+                    raise Exception(f"negRisk outcomeIndex out of range: {idx}")
+                amounts[idx] += size
+            else:
+                normal_conditions.add(condition_id)
+        txs: list[Any] = []
+        for condition_id, amounts in neg_amounts_by_condition.items():
+            int_amounts = [int(amount * 1e6) for amount in amounts]
+            txs.append(
+                self._build_redeem_tx(
+                    NEG_RISK_ADAPTER_ADDRESS,
+                    self.build_neg_risk_redeem_tx_data(condition_id, int_amounts),
+                )
+            )
+        for condition_id in normal_conditions:
+            txs.append(
+                self._build_redeem_tx(
+                    CTF_ADDRESS,
+                    self.build_ctf_redeem_tx_data(condition_id),
+                )
+            )
+        return txs
+
+    def _submit_redeem(self, txs: list[Any]) -> dict | None:
+        raise NotImplementedError("redeem submit not implemented")
+
+    def _redeem_batch(self, condition_ids: list[str], batch_size: int) -> list[dict]:
+        """
+        Fetch positions by condition IDs in batches, then redeem each batch.
+        """
+        if not condition_ids:
+            return []
+        user_address = self._resolve_user_address()
+        redeem_list = []
+        for batch in self._chunk_condition_ids(condition_ids, batch_size):
+            positions = self.fetch_positions_by_condition_ids(
+                user_address=user_address, condition_ids=batch
+            )
+            redeem_list.extend(self._redeem_from_positions(positions, len(batch)))
+        return redeem_list
+
+    def _redeem_from_positions(
+            self, positions: list[dict], batch_size: int
+    ) -> list[dict]:
+        """
+        Build and submit redeem transactions from a list of positions.
+        """
+        if not positions:
+            return []
+        positions_by_condition: dict[str, list[dict]] = {}
+        for pos in positions:
+            condition_id = pos.get("conditionId")
+            if not condition_id:
+                continue
+            positions_by_condition.setdefault(condition_id, []).append(pos)
+
+        redeem_list = []
+        error_list: list[str] = []
+        condition_ids = list(positions_by_condition.keys())
+        for batch in self._chunk_condition_ids(condition_ids, batch_size):
+            batch_positions = []
+            for condition_id in batch:
+                batch_positions.extend(positions_by_condition.get(condition_id, []))
+            try:
+                txs = self._build_redeem_txs_from_positions(batch_positions)
+                if not txs:
+                    continue
+                redeem_res = self._submit_redeem(txs)
+                redeem_list.append(redeem_res)
+                for pos in batch_positions:
+                    buy_price = pos.get("avgPrice")
+                    size = pos.get("size")
+                    if not buy_price or not size:
+                        continue
+                    volume = 1 / buy_price * (buy_price * size)
+                    logger.info(
+                        f"{pos.get('slug')} redeem success, volume={volume:.4f} usdc"
+                    )
+            except Exception as e:
+                error_list.extend(batch)
+                logger.info(f"redeem batch error, {batch=}, error={e}")
+        if error_list:
+            logger.warning(f"error redeem condition list, {error_list}")
+        return redeem_list
+
     @classmethod
     def _get_relay_payload(cls, address: str, wallet_type: WalletType):
         return requests.get(
@@ -198,11 +301,32 @@ class BaseWeb3Service:
         else:
             raise Exception("Estimate gas error: " + str(result))
 
+    @classmethod
+    def _chunk_condition_ids(
+            cls, condition_ids: list[str], batch_size: int
+    ) -> list[list[str]]:
+        if batch_size <= 0:
+            raise Exception("batch_size must be greater than 0")
+        return [
+            condition_ids[i: i + batch_size]
+            for i in range(0, len(condition_ids), batch_size)
+        ]
+
     def redeem(
             self,
             condition_ids: str | list[str],
-    ):  # noqa:
-        raise ImportError()
+            batch_size: int = 10,
+    ):
+        """
+        Redeem positions for the given condition IDs.
+        """
+        if isinstance(condition_ids, str):
+            condition_ids = [condition_ids]
+        return self._redeem_batch(condition_ids, batch_size)
 
-    def redeem_all(self) -> list[dict] | None:
-        raise ImportError()
+    def redeem_all(self, batch_size: int = 10) -> list[dict]:
+        """
+        Redeem all currently redeemable positions for the user.
+        """
+        positions = self.fetch_positions(user_address=self._resolve_user_address())
+        return self._redeem_from_positions(positions, batch_size)

poly_web3/web3_service/eoa_service.py

@@ -10,8 +10,10 @@ from poly_web3.web3_service.base import BaseWeb3Service
 class EOAWeb3Service(BaseWeb3Service):
     def redeem(
         self,
-        condition_id: str,
-        neg_risk: bool = False,
-        redeem_amounts: list[int] | None = None,
+        condition_ids: str | list[str],
+        batch_size: int = 10,
     ):
         raise ImportError("EOA wallet redeem not supported")
+
+    def redeem_all(self, batch_size: int = 10) -> list[dict]:
+        raise ImportError("EOA wallet redeem not supported")

poly_web3/web3_service/proxy_service.py

@@ -11,23 +11,26 @@ from eth_utils import to_bytes
 
 from poly_web3.const import (
     proxy_wallet_factory_abi,
-    CTF_ADDRESS,
     RELAYER_URL,
     PROXY_INIT_CODE_HASH,
     SUBMIT_TRANSACTION,
     STATE_MINED,
     STATE_CONFIRMED,
     STATE_FAILED,
-    NEG_RISK_ADAPTER_ADDRESS,
 )
 from poly_web3.web3_service.base import BaseWeb3Service
 from poly_web3.signature.build import derive_proxy_wallet, create_struct_hash
 from poly_web3.signature.hash_message import hash_message
 from poly_web3.signature import secp256k1
-from poly_web3.log import logger
-
-
 class ProxyWeb3Service(BaseWeb3Service):
+    def _build_redeem_tx(self, to: str, data: str) -> dict:
+        return {
+            "to": to,
+            "data": data,
+            "value": 0,
+            "typeCode": 1,
+        }
+
     def build_proxy_transaction_request(self, args: dict) -> dict:
         proxy_contract_config = self.get_contract_config()["ProxyContracts"]
         to = proxy_contract_config["ProxyFactory"]
@@ -94,70 +97,7 @@ class ProxyWeb3Service(BaseWeb3Service):
 
         return function_data
 
-    def _build_redeem_txs_from_positions(self, positions: list[dict]) -> list[dict]:
-        neg_amounts_by_condition: dict[str, list[float]] = {}
-        normal_conditions: set[str] = set()
-        for pos in positions:
-            condition_id = pos.get("conditionId")
-            if not condition_id:
-                continue
-            if pos.get("negativeRisk"):
-                idx = pos.get("outcomeIndex")
-                size = pos.get("size")
-                if idx is None or size is None:
-                    continue
-                amounts = neg_amounts_by_condition.setdefault(condition_id, [0.0, 0.0])
-                if idx not in (0, 1):
-                    raise Exception(f"negRisk outcomeIndex out of range: {idx}")
-                amounts[idx] += size
-            else:
-                normal_conditions.add(condition_id)
-        txs: list[dict] = []
-        for condition_id, amounts in neg_amounts_by_condition.items():
-            int_amounts = [int(amount * 1e6) for amount in amounts]
-            txs.append(
-                {
-                    "to": NEG_RISK_ADAPTER_ADDRESS,
-                    "data": self.build_neg_risk_redeem_tx_data(condition_id, int_amounts),
-                    "value": 0,
-                    "typeCode": 1,
-                }
-            )
-        for condition_id in normal_conditions:
-            txs.append(
-                {
-                    "to": CTF_ADDRESS,
-                    "data": self.build_ctf_redeem_tx_data(condition_id),
-                    "value": 0,
-                    "typeCode": 1,
-                }
-            )
-        return txs
-
-    @classmethod
-    def _chunk_condition_ids(
-            cls, condition_ids: list[str], batch_size: int
-    ) -> list[list[str]]:
-        if batch_size <= 0:
-            raise Exception("batch_size must be greater than 0")
-        return [
-            condition_ids[i: i + batch_size]
-            for i in range(0, len(condition_ids), batch_size)
-        ]
-
-    def _redeem_batch(self, condition_ids: list[str], batch_size: int) -> list[dict]:
-        if not condition_ids:
-            return []
-        user_address = self._resolve_user_address()
-        redeem_list = []
-        for batch in self._chunk_condition_ids(condition_ids, batch_size):
-            positions = self.fetch_positions_by_condition_ids(
-                user_address=user_address, condition_ids=batch
-            )
-            redeem_list.extend(self._redeem_from_positions(positions, len(batch)))
-        return redeem_list
-
-    def _submit_proxy_redeem(self, txs: list[dict]) -> dict:
+    def _submit_redeem(self, txs: list[dict]) -> dict:
         if self.clob_client is None:
             raise Exception("signer not found")
         _from = Web3.to_checksum_address(self.clob_client.get_address())
@@ -183,53 +123,3 @@ class ProxyWeb3Service(BaseWeb3Service):
             max_polls=100,
         )
         return redeem_res
-
-    def _redeem_from_positions(
-            self, positions: list[dict], batch_size: int
-    ) -> list[dict]:
-        if not positions:
-            return []
-        positions_by_condition: dict[str, list[dict]] = {}
-        for pos in positions:
-            condition_id = pos.get("conditionId")
-            if not condition_id:
-                continue
-            positions_by_condition.setdefault(condition_id, []).append(pos)
-
-        redeem_list = []
-        condition_ids = list(positions_by_condition.keys())
-        for batch in self._chunk_condition_ids(condition_ids, batch_size):
-            batch_positions = []
-            for condition_id in batch:
-                batch_positions.extend(positions_by_condition.get(condition_id, []))
-            try:
-                txs = self._build_redeem_txs_from_positions(batch_positions)
-                if not txs:
-                    continue
-                redeem_res = self._submit_proxy_redeem(txs)
-                redeem_list.append(redeem_res)
-                for pos in batch_positions:
-                    buy_price = pos.get("avgPrice")
-                    size = pos.get("size")
-                    if not buy_price or not size:
-                        continue
-                    volume = 1 / buy_price * (buy_price * size)
-                    logger.info(
-                        f"{pos.get('slug')} redeem success, volume={volume:.4f} usdc"
-                    )
-            except Exception as e:
-                logger.info(f"redeem batch error, {batch=}, error={e}")
-        return redeem_list
-
-    def redeem(
-            self,
-            condition_ids: str | list[str],
-            batch_size: int = 10,
-    ):
-        if isinstance(condition_ids, str):
-            condition_ids = [condition_ids]
-        return self._redeem_batch(condition_ids, batch_size)
-
-    def redeem_all(self, batch_size: int = 10) -> list[dict]:
-        positions = self.fetch_positions(user_address=self._resolve_user_address())
-        return self._redeem_from_positions(positions, batch_size)

poly_web3/web3_service/safe_service.py

@@ -4,14 +4,21 @@
 # @Site:
 # @File: safe_service.py
 # @Software: PyCharm
+from py_builder_relayer_client.models import OperationType, SafeTransaction
 from poly_web3.web3_service.base import BaseWeb3Service
 
 
 class SafeWeb3Service(BaseWeb3Service):
-    def redeem(
-        self,
-        condition_id: str,
-        neg_risk: bool = False,
-        redeem_amounts: list[int] | None = None,
-    ):
-        raise ImportError("Safe wallet redeem not supported")
+    def _build_redeem_tx(self, to: str, data: str) -> SafeTransaction:
+        return SafeTransaction(
+            to=to,
+            data=data,
+            value="0",
+            operation=OperationType.Call,
+        )
+
+    def _submit_redeem(self, txs: list[SafeTransaction]) -> dict | None:
+        if self.relayer_client is None:
+            raise Exception("relayer_client not found")
+        resp = self.relayer_client.execute(txs, "redeem")
+        return resp.wait()

{poly_web3-0.0.5.dist-info → poly_web3-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: poly-web3
-Version: 0.0.5
+Version: 1.0.0
 Summary: Polymarket Proxy wallet redeem SDK - Execute redeem operations on Polymarket using proxy wallets
 Home-page: https://github.com/tosmart01/poly-web3
 Author: PinBar

{poly_web3-0.0.5.dist-info → poly_web3-1.0.0.dist-info}/RECORD

@@ -1,18 +1,18 @@
 examples/example_redeem.py,sha256=grSaAsmjgQDKd1zpd17-cYkAv7fkqFUqDEvCr3gXJtA,2149
 poly_web3/__init__.py,sha256=O4xBBGCQoO453RdGZ9eWpjpOEOz_kFoU_TTnigbBaPs,1078
 poly_web3/const.py,sha256=UYBs1b9P2YJw1isbUzlGOxMWIqWyRiyGt9D2WmZCYfU,4959
-poly_web3/log.py,sha256=63XRfNTyZoQCgS5DRnZCdrMyQM1C-4bXhQ-izyvYWNI,1254
+poly_web3/log.py,sha256=NPY6X7Ysw-5ds3JkA26vhfge2Dc39ptezmCWYbwT-FM,986
 poly_web3/schema.py,sha256=GTzpEy8-mqw2fCqoQKQFn6ieyhXdSnW6I9YQMKGnnhM,435
 poly_web3/signature/__init__.py,sha256=p4EwohjUtwEsFqrc7eeqY5sQa14GWc8BdR6km8c7SH8,123
 poly_web3/signature/build.py,sha256=PEyMFbE2PM2Xvz3wvmA6T6FVnU3mB7uanoEutbneFQ8,3614
 poly_web3/signature/hash_message.py,sha256=hREtjuOdLcm_IlBz1YuzyrObVdxs7Yn-ULfh09PeNmk,1319
 poly_web3/signature/secp256k1.py,sha256=IBgp0vNJyskU7ZUcWCdDttrzmJgEWH6lakB74whur_w,1500
 poly_web3/web3_service/__init__.py,sha256=HNRh06yZNYXDmGS69ISXG7_PPG9foGXLyHOdnbgYXk0,315
-poly_web3/web3_service/base.py,sha256=cchUlqcLiOfThDFolWHudrEX6NM5sPUYpVcAkX3xung,7136
-poly_web3/web3_service/eoa_service.py,sha256=_5nmTX7aG4u5QMECwqVOdaYK4bgE5yI1BsW4aT_UiFU,429
-poly_web3/web3_service/proxy_service.py,sha256=TX9SVboIG7X_MeIN1diSqv8MEz9k7YrR2M4Ks8-n7Og,8650
-poly_web3/web3_service/safe_service.py,sha256=emT7h5JmvgFKX_Rl4YP8Zj5MOLNf_4QHx8Ts1lb3WJo,432
-poly_web3-0.0.5.dist-info/METADATA,sha256=2dsBnvsJr3QjXO47F6FZhJUIsoiJkUNPQdpk8_bq-xY,9765
-poly_web3-0.0.5.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-poly_web3-0.0.5.dist-info/top_level.txt,sha256=wW40wsocHfhFgqSWWvYWrhwKGQU5IWkhyaz5J90vmHo,19
-poly_web3-0.0.5.dist-info/RECORD,,
+poly_web3/web3_service/base.py,sha256=SwiJ3nTPHUTYH5gDwjDPRoxjZNICfYKsy6w4pWiG73U,12195
+poly_web3/web3_service/eoa_service.py,sha256=mTJ0OHJvpzkrYvom1wDlA7EyV_tJFwxekpgPSXMXz0Y,515
+poly_web3/web3_service/proxy_service.py,sha256=-Odgpq24dKnBmtuwQ3RRINS88zzTFEQCbtaTZ4WNLs8,4181
+poly_web3/web3_service/safe_service.py,sha256=D9rHcxbU9rjvDd5k__qu8MCZ8srdQITS8g4JNkoE7Uo,776
+poly_web3-1.0.0.dist-info/METADATA,sha256=7r6FXHqXFPdPz8IpQHSEoI-Qm0-ZdrgVL1k_UiZf0fc,9765
+poly_web3-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+poly_web3-1.0.0.dist-info/top_level.txt,sha256=wW40wsocHfhFgqSWWvYWrhwKGQU5IWkhyaz5J90vmHo,19
+poly_web3-1.0.0.dist-info/RECORD,,