poly-web3 0.0.1__py3-none-any.whl

examples/example_redeem.py

@@ -0,0 +1,54 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025-12-27 17:01:20
+# @Author: PinBar
+# @Site:
+# @File: example_redeem.py
+# @Software: PyCharm
+import os
+
+import dotenv
+from py_builder_relayer_client.client import RelayClient
+from py_builder_signing_sdk.config import BuilderConfig
+from py_builder_signing_sdk.sdk_types import BuilderApiKeyCreds
+
+from py_clob_client.client import ClobClient
+
+from poly_web3 import RELAYER_URL, PolyWeb3Service
+
+dotenv.load_dotenv()
+
+if __name__ == "__main__":
+    host: str = "https://clob.polymarket.com"
+    chain_id: int = 137  # No need to adjust this
+    client = ClobClient(
+        host,
+        key=os.getenv("POLY_API_KEY"),
+        chain_id=chain_id,
+        signature_type=1,
+        funder=os.getenv("POLYMARKET_PROXY_ADDRESS"),
+    )
+    creds = client.create_or_derive_api_creds()
+    client.set_api_creds(creds)
+    relayer_client = RelayClient(
+        RELAYER_URL,
+        chain_id,
+        os.getenv("POLY_API_KEY"),
+        BuilderConfig(
+            local_builder_creds=BuilderApiKeyCreds(
+                key=os.getenv("BUILDER_KEY"),
+                secret=os.getenv("BUILDER_SECRET"),
+                passphrase=os.getenv("BUILDER_PASSPHRASE"),
+            )
+        ),
+    )
+    condition_id = "0xc3df016175463c44f9c9f98bddaa3bf3daaabb14b069fb7869621cffe73ddd1c"
+    service = PolyWeb3Service(clob_client=client, relayer_client=relayer_client)
+    redeem = service.redeem(condition_id=condition_id)
+    print(redeem)
+
+    # Optional - Query operations (可选操作，用于查询)
+    # can_redeem = service.is_condition_resolved(condition_id)
+    # redeem_balance = service.get_redeemable_index_and_balance(
+    #     condition_id, owner=client.builder.funder
+    # )
+    # print(can_redeem, redeem_balance)

poly_web3/__init__.py

@@ -0,0 +1,31 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025/12/19 15:24
+# @Author: PinBar
+# @Site:
+# @File: __init__.py.py
+# @Software: PyCharm
+from typing import Union
+
+from py_clob_client.client import ClobClient
+from py_builder_relayer_client.client import RelayClient
+
+from poly_web3.const import RELAYER_URL
+from poly_web3.web3_service.base import BaseWeb3Service
+from poly_web3.schema import WalletType
+from poly_web3.web3_service import SafeWeb3Service, EOAWeb3Service, ProxyWeb3Service
+
+
+def PolyWeb3Service(
+    clob_client: ClobClient, relayer_client: RelayClient = None
+) -> Union[SafeWeb3Service, EOAWeb3Service, ProxyWeb3Service]:  # noqa
+    services = {
+        WalletType.EOA: EOAWeb3Service,
+        WalletType.PROXY: ProxyWeb3Service,
+        WalletType.SAFE: SafeWeb3Service,
+    }
+
+    wallet_type = WalletType.get_with_code(clob_client.builder.sig_type)
+    if service := services.get(wallet_type):
+        return service(clob_client, relayer_client)
+    else:
+        raise Exception(f"Unknown wallet type: {wallet_type}")

poly_web3/const.py

@@ -0,0 +1,171 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025/12/19 15:29
+# @Author: PinBar
+# @Site:
+# @File: const.py
+# @Software: PyCharm
+from web3 import Web3
+
+GET_NONCE = "/nonce"
+GET_RELAY_PAYLOAD = "/relay-payload"
+GET_TRANSACTION = "/transaction"
+GET_TRANSACTIONS = "/transactions"
+SUBMIT_TRANSACTION = "/submit"
+GET_DEPLOYED = "/deployed"
+RPC_URL = "https://polygon-rpc.com"
+RELAYER_URL = "https://relayer-v2.polymarket.com"
+
+STATE_NEW = ("STATE_NEW",)
+STATE_EXECUTED = "STATE_EXECUTED"
+STATE_MINED = "STATE_MINED"
+STATE_INVALID = "STATE_INVALID"
+STATE_CONFIRMED = "STATE_CONFIRMED"
+STATE_FAILED = "STATE_FAILED"
+
+# address
+CTF_ADDRESS = Web3.to_checksum_address("0x4d97dcd97ec945f40cf65f87097ace5ea0476045")
+USDC_POLYGON = Web3.to_checksum_address("0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174")
+NEG_RISK_ADAPTER_ADDRESS = Web3.to_checksum_address(
+    "0xd91E80cF2E7be2e162c6513ceD06f1dD0dA35296"
+)
+ZERO_BYTES32 = "0x" + "00" * 32
+proxy_factory_address = Web3.to_checksum_address(
+    "0xaB45c5A4B0c941a2F231C04C3f49182e1A254052"
+)
+SAFE_INIT_CODE_HASH = (
+    "0x2bce2127ff07fb632d16c8347c4ebf501f4841168bed00d9e6ef715ddb6fcecf"
+)
+PROXY_INIT_CODE_HASH = (
+    "0xd21df8dc65880a8606f09fe0ce3df9b8869287ab0b058be05aa9e8af6330a00b"
+)
+
+AMOY = {
+    "ProxyContracts": {
+        # Proxy factory unsupported on Amoy testnet
+        "RelayHub": "",
+        "ProxyFactory": "",
+    },
+    "SafeContracts": {
+        "SafeFactory": "0xaacFeEa03eb1561C4e67d661e40682Bd20E3541b",
+        "SafeMultisend": "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761",
+    },
+}
+
+POL = {
+    "ProxyContracts": {
+        "ProxyFactory": "0xaB45c5A4B0c941a2F231C04C3f49182e1A254052",
+        "RelayHub": "0xD216153c06E857cD7f72665E0aF1d7D82172F494",
+    },
+    "SafeContracts": {
+        "SafeFactory": "0xaacFeEa03eb1561C4e67d661e40682Bd20E3541b",
+        "SafeMultisend": "0xA238CBeb142c10Ef7Ad8442C6D1f9E89e07e7761",
+    },
+}
+
+# abi
+CTF_ABI_REDEEM = [
+    {
+        "name": "redeemPositions",
+        "type": "function",
+        "stateMutability": "nonpayable",
+        "inputs": [
+            {"name": "collateralToken", "type": "address"},
+            {"name": "parentCollectionId", "type": "bytes32"},
+            {"name": "conditionId", "type": "bytes32"},
+            {"name": "indexSets", "type": "uint256[]"},
+        ],
+        "outputs": [],
+    }
+]
+
+NEG_RISK_ADAPTER_ABI_REDEEM = [
+    {
+        "name": "redeemPositions",
+        "type": "function",
+        "stateMutability": "nonpayable",
+        "inputs": [
+            {"name": "_conditionId", "type": "bytes32"},
+            {"name": "_amounts", "type": "uint256[]"},
+        ],
+        "outputs": [],
+    }
+]
+
+proxy_wallet_factory_abi = [
+    {
+        "inputs": [
+            {
+                "components": [
+                    {"name": "typeCode", "type": "uint8"},
+                    {"name": "to", "type": "address"},
+                    {"name": "value", "type": "uint256"},
+                    {"name": "data", "type": "bytes"},
+                ],
+                "name": "calls",
+                "type": "tuple[]",
+            }
+        ],
+        "name": "proxy",
+        "outputs": [{"name": "returnValues", "type": "bytes[]"}],
+        "stateMutability": "payable",
+        "type": "function",
+    }
+]
+
+CTF_ABI_PAYOUT = [
+    {
+        "name": "payoutDenominator",
+        "type": "function",
+        "stateMutability": "view",
+        "inputs": [{"name": "conditionId", "type": "bytes32"}],
+        "outputs": [{"type": "uint256"}],
+    },
+    {
+        "name": "payoutNumerators",
+        "type": "function",
+        "stateMutability": "view",
+        "inputs": [
+            {"name": "conditionId", "type": "bytes32"},
+            {"name": "index", "type": "uint256"},
+        ],
+        "outputs": [{"type": "uint256"}],
+    },
+    {
+        "name": "getOutcomeSlotCount",
+        "type": "function",
+        "stateMutability": "view",
+        "inputs": [{"name": "conditionId", "type": "bytes32"}],
+        "outputs": [{"type": "uint256"}],
+    },
+    {
+        "name": "getCollectionId",
+        "type": "function",
+        "stateMutability": "view",
+        "inputs": [
+            {"name": "parentCollectionId", "type": "bytes32"},
+            {"name": "conditionId", "type": "bytes32"},
+            {"name": "indexSet", "type": "uint256"},
+        ],
+        "outputs": [{"type": "bytes32"}],
+    },
+    {
+        "name": "getPositionId",
+        "type": "function",
+        "stateMutability": "view",
+        "inputs": [
+            {"name": "collateralToken", "type": "address"},
+            {"name": "collectionId", "type": "bytes32"},
+        ],
+        "outputs": [{"type": "uint256"}],
+    },
+    {
+        "name": "balanceOf",
+        "type": "function",
+        "stateMutability": "view",
+        "inputs": [
+            {"name": "owner", "type": "address"},
+            {"name": "id", "type": "uint256"},
+        ],
+        "outputs": [{"type": "uint256"}],
+    },
+]

poly_web3/schema.py

@@ -0,0 +1,22 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025/12/19 15:31
+# @Author: PinBar
+# @Site:
+# @File: model.py
+# @Software: PyCharm
+from enum import Enum
+
+
+class WalletType(str, Enum):
+    EOA = "EOA"
+    SAFE = "SAFE"
+    PROXY = "PROXY"
+
+    @classmethod
+    def get_with_code(cls, code: int):
+        if code == 0:
+            return cls.EOA
+        elif code == 1:
+            return cls.PROXY
+        elif code == 2:
+            return cls.SAFE

poly_web3/signature/__init__.py

@@ -0,0 +1,6 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025/12/21 19:42
+# @Author: PinBar
+# @Site:
+# @File: __init__.py.py
+# @Software: PyCharm

poly_web3/signature/build.py

@@ -0,0 +1,113 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025/12/21 19:45
+# @Author: PinBar
+# @Site:
+# @File: build.py
+# @Software: PyCharm
+from typing import Union, Optional
+
+
+def string_to_bytes(value: str, size: Optional[int] = None) -> bytes:
+    data = value.encode("utf-8")
+    if size is None:
+        return data
+    if len(data) > size:
+        raise ValueError(f"Size overflow: given {len(data)}, max {size}")
+    return data + b"\x00" * (size - len(data))
+
+
+def keccak256(data: bytes) -> bytes:
+    try:
+        from eth_hash.auto import keccak
+
+        return keccak(data)
+    except Exception:
+        try:
+            import sha3  # pysha3
+
+            k = sha3.keccak_256()
+        except Exception:
+            from Crypto.Hash import keccak  # pycryptodome
+
+            k = keccak.new(digest_bits=256)
+        k.update(data)
+        return k.digest()
+
+
+def to_checksum_address(addr_bytes: bytes) -> str:
+    hex_addr = addr_bytes.hex()
+    hash_hex = keccak256(hex_addr.encode()).hex()
+    checksum = "".join(
+        ch.upper() if int(hash_hex[i], 16) >= 8 else ch for i, ch in enumerate(hex_addr)
+    )
+    return "0x" + checksum
+
+
+def derive_proxy_wallet(address: str, proxy_factory: str, bytecode_hash: str) -> str:
+    addr_bytes = bytes.fromhex(address[2:] if address.startswith("0x") else address)
+    factory_bytes = bytes.fromhex(
+        proxy_factory[2:] if proxy_factory.startswith("0x") else proxy_factory
+    )
+    bytecode_bytes = bytes.fromhex(
+        bytecode_hash[2:] if bytecode_hash.startswith("0x") else bytecode_hash
+    )
+    salt = keccak256(
+        addr_bytes
+    )  # equivalent to keccak256(encodePacked(["address"], [address]))
+    data = b"\xff" + factory_bytes + salt + bytecode_bytes
+    create2_hash = keccak256(data)
+    return to_checksum_address(create2_hash[12:])  # last 20 bytes
+
+
+HexLike = Union[str, bytes, int]
+
+
+def create_struct_hash(
+    from_addr: str,
+    to: str,
+    data: str,
+    tx_fee: HexLike,
+    gas_price: HexLike,
+    gas_limit: HexLike,
+    nonce: HexLike,
+    relay_hub_address: str,
+    relay_address: str,
+) -> str:
+    def to_bytes(hex_like: HexLike, size: int | None = None) -> bytes:
+        if isinstance(hex_like, int):
+            length = (
+                size if size is not None else max(1, (hex_like.bit_length() + 7) // 8)
+            )
+            return hex_like.to_bytes(length, "big")
+        if isinstance(hex_like, bytes):
+            return hex_like.rjust(size, b"\x00") if size else hex_like
+        if isinstance(hex_like, str):
+            if hex_like.startswith("0x"):
+                raw = bytes.fromhex(hex_like[2:])
+                return raw.rjust(size, b"\x00") if size else raw
+            if hex_like.isdigit():  # numeric string -> int
+                num = int(hex_like)
+                length = (
+                    size if size is not None else max(1, (num.bit_length() + 7) // 8)
+                )
+                return num.to_bytes(length, "big")
+            raw = hex_like.encode()  # fallback ascii
+            return raw.rjust(size, b"\x00") if size else raw
+        raise TypeError("Unsupported type for to_bytes")
+
+    relay_hub_prefix = to_bytes("rlx:")
+    data_to_hash = b"".join(
+        [
+            relay_hub_prefix,
+            to_bytes(from_addr),
+            to_bytes(to),
+            to_bytes(data),
+            to_bytes(tx_fee, size=32),
+            to_bytes(gas_price, size=32),
+            to_bytes(gas_limit, size=32),
+            to_bytes(nonce, size=32),
+            to_bytes(relay_hub_address),
+            to_bytes(relay_address),
+        ]
+    )
+    return "0x" + keccak256(data_to_hash).hex()

poly_web3/signature/hash_message.py

@@ -0,0 +1,48 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025/12/21 19:43
+# @Author: PinBar
+# @Site:
+# @File: hash_message.py
+# @Software: PyCharm
+from eth_hash.auto import keccak
+
+
+def _is_hex(s: str) -> bool:
+    return isinstance(s, str) and s.startswith("0x")
+
+
+def _hex_to_bytes(h: str) -> bytes:
+    # 假设是 0x 前缀
+    return bytes.fromhex(h[2:])
+
+
+def _size_of_message(value) -> int:
+    # 对齐 viem: hex -> (len-2)/2 向上取整, bytes -> len
+    if _is_hex(value):
+        return (len(value) - 2 + 1) // 2
+    return len(value)
+
+
+def _to_prefixed_message(message) -> bytes:
+    if isinstance(message, str):
+        msg_bytes = message.encode("utf-8")
+    elif isinstance(message, dict) and "raw" in message:
+        raw = message["raw"]
+        if isinstance(raw, str):
+            # viem 这里直接当作 hex 字符串使用
+            msg_bytes = _hex_to_bytes(raw)
+        else:
+            # raw 可以是 list[int], bytes, bytearray
+            msg_bytes = bytes(raw)
+    else:
+        raise TypeError("Unsupported SignableMessage")
+
+    prefix = f"\x19Ethereum Signed Message:\n{len(msg_bytes)}".encode("utf-8")
+    return prefix + msg_bytes
+
+
+def hash_message(message, to: str = "hex"):
+    digest = keccak(_to_prefixed_message(message))
+    if to == "bytes":
+        return digest
+    return "0x" + digest.hex()

poly_web3/signature/secp256k1.py

@@ -0,0 +1,57 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025/12/21 19:44
+# @Author: PinBar
+# @Site:
+# @File: secp256k1.py
+# @Software: PyCharm
+from eth_keys import keys
+from eth_utils import decode_hex
+
+SECP256K1_N = int(
+    "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141", 16
+)
+HALF_N = SECP256K1_N // 2
+
+
+def sign(hash_hex: str, priv_hex: str):
+    msg = decode_hex(hash_hex)
+    priv = keys.PrivateKey(decode_hex(priv_hex))
+    sig = priv.sign_msg_hash(msg)
+    r, s, v = sig.r, sig.s, sig.v
+
+    if s > HALF_N:
+        s = SECP256K1_N - s
+        # Ethereum recovery id flips when s is negated
+        v ^= 1
+
+    return r, s, v
+
+
+def int_to_hex(n: int, size: int = 32) -> str:
+    # size 是字节数，32 字节 -> 64 个 hex 字符
+    return "0x" + n.to_bytes(size, "big").hex()
+
+
+def hex_to_int(h: str) -> int:
+    return int(h, 16)
+
+
+def serialize_signature(r: str, s: str, v=None, yParity=None, to="hex"):
+    # 计算 yParity_
+    if yParity in (0, 1):
+        yParity_ = yParity
+    elif v is not None and (v in (27, 28) or v >= 35):
+        yParity_ = 1 if (v % 2 == 0) else 0
+    else:
+        raise ValueError("Invalid `v` or `yParity` value")
+
+    # toCompactHex: r||s (各 32 字节)
+    r_int = hex_to_int(r)
+    s_int = hex_to_int(s)
+    compact = r_int.to_bytes(32, "big").hex() + s_int.to_bytes(32, "big").hex()
+
+    signature_hex = "0x" + compact + ("1b" if yParity_ == 0 else "1c")
+
+    if to == "hex":
+        return signature_hex
+    return bytes.fromhex(signature_hex[2:])

poly_web3/web3_service/__init__.py

@@ -0,0 +1,9 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025-12-27 16:07:53
+# @Author: PinBar
+# @Site:
+# @File: __init__.py
+# @Software: PyCharm
+from poly_web3.web3_service.eoa_service import EOAWeb3Service
+from poly_web3.web3_service.proxy_service import ProxyWeb3Service
+from poly_web3.web3_service.safe_service import SafeWeb3Service

poly_web3/web3_service/base.py

@@ -0,0 +1,143 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025-12-27 15:57:07
+# @Author: PinBar
+# @Site:
+# @File: base.py
+# @Software: PyCharm
+import requests
+from py_builder_relayer_client.client import RelayClient
+from py_clob_client.client import ClobClient
+from web3 import Web3
+
+from poly_web3.const import (
+    RPC_URL,
+    CTF_ADDRESS,
+    CTF_ABI_PAYOUT,
+    ZERO_BYTES32,
+    USDC_POLYGON,
+    CTF_ABI_REDEEM,
+    NEG_RISK_ADAPTER_ADDRESS,
+    RELAYER_URL,
+    POL,
+    AMOY,
+    GET_RELAY_PAYLOAD,
+    NEG_RISK_ADAPTER_ABI_REDEEM,
+)
+from poly_web3.schema import WalletType
+
+
+class BaseWeb3Service:
+    def __init__(
+        self,
+        clob_client: ClobClient = None,
+        relayer_client: RelayClient = None,
+    ):
+        self.relayer_client = relayer_client
+        self.clob_client: ClobClient = clob_client
+        if self.clob_client:
+            self.wallet_type: WalletType = WalletType.get_with_code(
+                self.clob_client.builder.sig_type
+            )
+        else:
+            self.wallet_type = WalletType.PROXY
+        self.w3: Web3 = Web3(Web3.HTTPProvider(RPC_URL))
+        if self.wallet_type == WalletType.PROXY and relayer_client is None:
+            raise Exception("relayer_client must be provided")
+
+    def is_condition_resolved(self, condition_id: str) -> bool:
+        ctf = self.w3.eth.contract(address=CTF_ADDRESS, abi=CTF_ABI_PAYOUT)
+        return ctf.functions.payoutDenominator(condition_id).call() > 0
+
+    def get_winning_indexes(self, condition_id: str) -> list[int]:
+        ctf = self.w3.eth.contract(address=CTF_ADDRESS, abi=CTF_ABI_PAYOUT)
+        if not self.is_condition_resolved(condition_id):
+            return []
+        outcome_count = ctf.functions.getOutcomeSlotCount(condition_id).call()
+        winners: list[int] = []
+        for i in range(outcome_count):
+            if ctf.functions.payoutNumerators(condition_id, i).call() > 0:
+                winners.append(i)
+        return winners
+
+    def get_redeemable_index_and_balance(
+        self, condition_id: str, owner: str
+    ) -> list[tuple]:
+        winners = self.get_winning_indexes(condition_id)
+        if not winners:
+            return []
+        ctf = self.w3.eth.contract(address=CTF_ADDRESS, abi=CTF_ABI_PAYOUT)
+        owner_checksum = Web3.to_checksum_address(owner)
+        redeemable: list[tuple] = []
+        for index in winners:
+            index_set = 1 << index
+            collection_id = ctf.functions.getCollectionId(
+                ZERO_BYTES32, condition_id, index_set
+            ).call()
+            position_id = ctf.functions.getPositionId(
+                USDC_POLYGON, collection_id
+            ).call()
+            balance = ctf.functions.balanceOf(owner_checksum, position_id).call()
+            if balance > 0:
+                redeemable.append((index, balance / 1000000))
+        return redeemable
+
+    def build_ctf_redeem_tx_data(self, condition_id: str) -> str:
+        ctf = self.w3.eth.contract(address=CTF_ADDRESS, abi=CTF_ABI_REDEEM)
+        # 只需要 calldata：encodeABI 即可
+        return ctf.functions.redeemPositions(
+            USDC_POLYGON,
+            ZERO_BYTES32,
+            condition_id,
+            [1, 2],
+        )._encode_transaction_data()
+
+    def build_neg_risk_redeem_tx_data(
+        self, condition_id: str, redeem_amounts: list[int]
+    ) -> str:
+        nr_adapter = self.w3.eth.contract(
+            address=NEG_RISK_ADAPTER_ADDRESS, abi=NEG_RISK_ADAPTER_ABI_REDEEM
+        )
+        return nr_adapter.functions.redeemPositions(
+            condition_id,
+            redeem_amounts,
+        )._encode_transaction_data()
+
+    @classmethod
+    def _get_relay_payload(cls, address: str, wallet_type: WalletType):
+        return requests.get(
+            RELAYER_URL + GET_RELAY_PAYLOAD,
+            params={"address": address, "type": wallet_type},
+        ).json()
+
+    def get_contract_config(self) -> dict:
+        if self.clob_client.chain_id == 137:
+            return POL
+        elif self.clob_client.chain_id == 80002:
+            return AMOY
+        raise Exception("Invalid network")
+
+    def estimate_gas(self, tx):
+        payload = {
+            "jsonrpc": "2.0",
+            "method": "eth_estimateGas",
+            "params": [tx],
+            "id": 1,
+        }
+
+        response = requests.post(RPC_URL, json=payload)
+        result = response.json()
+
+        if "result" in result:
+            # 返回的是16进制 gas 数量
+            gas_hex = result["result"]
+            return str(int(gas_hex, 16))
+        else:
+            raise Exception("Estimate gas error: " + str(result))
+
+    def redeem(
+        self,
+        condition_id: str,
+        neg_risk: bool = False,
+        redeem_amounts: list[int] | None = None,
+    ):  # noqa:
+        raise ImportError()

poly_web3/web3_service/eoa_service.py

@@ -0,0 +1,17 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025-12-27 16:01:09
+# @Author: PinBar
+# @Site:
+# @File: eoa_service.py
+# @Software: PyCharm
+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,
+    ):
+        raise ImportError("EOA wallet redeem not supported")

poly_web3/web3_service/proxy_service.py

@@ -0,0 +1,135 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025-12-27 16:00:42
+# @Author: PinBar
+# @Site:
+# @File: proxy_service.py
+# @Software: PyCharm
+import requests
+
+from web3 import Web3
+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
+
+
+class ProxyWeb3Service(BaseWeb3Service):
+    def build_proxy_transaction_request(self, args: dict) -> dict:
+        proxy_contract_config = self.get_contract_config()["ProxyContracts"]
+        to = proxy_contract_config["ProxyFactory"]
+        proxy = derive_proxy_wallet(args["from"], to, PROXY_INIT_CODE_HASH)
+        relayer_fee = "0"
+        relay_hub = proxy_contract_config["RelayHub"]
+        gas_limit_str = self.estimate_gas(
+            tx={"from": args["from"], "to": to, "data": args["data"]}
+        )
+        sig_params = {
+            "gasPrice": args.get("gasPrice"),
+            "gasLimit": gas_limit_str,
+            "relayerFee": relayer_fee,
+            "relayHub": relay_hub,
+            "relay": args.get("relay"),
+        }
+        tx_hash = create_struct_hash(
+            args["from"],
+            to,
+            args["data"],
+            relayer_fee,
+            args.get("gasPrice"),
+            gas_limit_str,
+            args["nonce"],
+            relay_hub,
+            args.get("relay"),
+        )
+        message = {"raw": list(to_bytes(hexstr=tx_hash))}
+
+        r, s, recovery = secp256k1.sign(
+            hash_message(message)[2:], self.clob_client.signer.private_key
+        )
+        signature = {
+            "r": secp256k1.int_to_hex(r, 32),
+            "s": secp256k1.int_to_hex(s, 32),
+            "v": 28 if recovery else 27,
+            "yParity": recovery,
+        }
+        final_sig = secp256k1.serialize_signature(**signature, to="hex")
+        req = {
+            "from": args["from"],
+            "to": to,
+            "proxyWallet": proxy,
+            "data": args["data"],
+            "nonce": args["nonce"],
+            "signature": final_sig,
+            "signatureParams": sig_params,
+            "type": self.wallet_type.value,
+            "metadata": "redeem",
+        }
+        return req
+
+    def encode_proxy_transaction_data(self, txns):
+        # Prepare the arguments for the 'proxy' function
+        calls_data = [
+            (txn["typeCode"], txn["to"], txn["value"], txn["data"]) for txn in txns
+        ]
+
+        # Create the contract object
+        contract = self.w3.eth.contract(abi=proxy_wallet_factory_abi)
+
+        # Encode function data
+        function_data = contract.encodeABI(fn_name="proxy", args=[calls_data])
+
+        return function_data
+
+    def redeem(
+        self,
+        condition_id: str,
+        neg_risk: bool = False,
+        redeem_amounts: list[int] | None = None,
+    ):
+        if neg_risk:
+            if redeem_amounts is None or len(redeem_amounts) != 2:
+                raise Exception("negRisk redeem requires redeem_amounts with length 2")
+            tx_data = self.build_neg_risk_redeem_tx_data(condition_id, redeem_amounts)
+            tx_to = NEG_RISK_ADAPTER_ADDRESS
+        else:
+            tx_data = self.build_ctf_redeem_tx_data(condition_id)
+            tx_to = CTF_ADDRESS
+        tx = {"to": tx_to, "data": tx_data, "value": 0, "typeCode": 1}
+        if self.clob_client is None:
+            raise Exception("signer not found")
+        _from = Web3.to_checksum_address(self.clob_client.get_address())
+        rp = self._get_relay_payload(_from, self.wallet_type)
+        args = {
+            "from": _from,
+            "gasPrice": "0",
+            "data": self.encode_proxy_transaction_data([tx]),
+            "relay": rp["address"],
+            "nonce": rp["nonce"],
+        }
+        req = self.build_proxy_transaction_request(args)
+        headers = self.relayer_client._generate_builder_headers(
+            "POST", SUBMIT_TRANSACTION, req
+        )
+        response = requests.post(
+            RELAYER_URL + SUBMIT_TRANSACTION, json=req, headers=headers
+        ).json()
+        redeem_res = self.relayer_client.poll_until_state(
+            transaction_id=response["transactionID"],
+            states=[STATE_MINED, STATE_CONFIRMED],
+            fail_state=STATE_FAILED,
+            max_polls=100,
+        )
+        return redeem_res

poly_web3/web3_service/safe_service.py

@@ -0,0 +1,17 @@
+# -*- coding = utf-8 -*-
+# @Time: 2025-12-27 16:01:00
+# @Author: PinBar
+# @Site:
+# @File: safe_service.py
+# @Software: PyCharm
+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")

poly_web3-0.0.1.dist-info/METADATA

@@ -0,0 +1,275 @@
+Metadata-Version: 2.4
+Name: poly-web3
+Version: 0.0.1
+Summary: Polymarket Proxy wallet redeem SDK - Execute redeem operations on Polymarket using proxy wallets
+Home-page: https://github.com/tosmart01/poly-web3
+Author: PinBar
+Project-URL: Homepage, https://github.com/tosmart01/poly-web3
+Project-URL: Repository, https://github.com/tosmart01/poly-web3
+Project-URL: Bug Tracker, https://github.com/tosmart01/poly-web3/issues
+Keywords: polymarket,web3,proxy,wallet,redeem,blockchain,polygon
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Internet :: WWW/HTTP
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+Requires-Dist: py-clob-client>=0.25.0
+Requires-Dist: py-builder-relayer-client>=0.0.1
+Requires-Dist: web3==6.8
+Requires-Dist: eth-utils==5.3.1
+Requires-Dist: setuptools>=80.9.0
+Dynamic: home-page
+Dynamic: requires-python
+
+# poly-web3
+
+Python SDK for Polymarket Proxy wallet redeem operations. Supports executing Conditional Token Fund (CTF) redeem operations on Polymarket through proxy wallets.
+
+[English](README.md) | [中文](README.zh.md)
+
+## About the Project
+
+This project is a Python rewrite of Polymarket's official TypeScript implementation of `builder-relayer-client`, designed to provide Python developers with a convenient tool for executing proxy wallet redeem operations on Polymarket.
+
+**Important Notes:**
+- This project **only implements the official redeem functionality**, focusing on Conditional Token Fund (CTF) redeem operations
+- Other features (such as trading, order placement, etc.) are not within the scope of this project
+
+**Current Status:**
+- ✅ **Proxy Wallet** - Fully supported for redeem functionality
+- 🚧 **Safe Wallet** - Under development
+- 🚧 **EOA Wallet** - Under development
+
+We welcome community contributions! If you'd like to help implement Safe or EOA wallet redeem functionality, or have other improvement suggestions, please feel free to submit a Pull Request.
+
+## Features
+
+- ✅ Support for Polymarket Proxy wallet redeem operations (currently only Proxy wallet is supported)
+- ✅ Check if conditions are resolved
+- ✅ Get redeemable indexes and balances
+- ✅ Support for standard CTF redeem and negative risk (neg_risk) redeem
+- ✅ Automatic transaction execution through Relayer service
+
+## Installation
+
+```bash
+pip install poly-web3
+```
+
+Or using uv:
+
+```bash
+uv add poly-web3
+```
+
+## Requirements
+
+- Python >= 3.11
+
+## Dependencies
+
+- `py-clob-client >= 0.25.0` - Polymarket CLOB client
+- `py-builder-relayer-client >= 0.0.1` - Builder Relayer client
+- `web3 == 6.8` - Web3.py library
+- `eth-utils == 5.3.1` - Ethereum utilities library
+
+## Quick Start
+
+### Basic Usage - Execute Redeem
+
+```python
+import os
+import dotenv
+from py_builder_relayer_client.client import RelayClient
+from py_builder_signing_sdk.config import BuilderConfig
+from py_builder_signing_sdk.sdk_types import BuilderApiKeyCreds
+from py_clob_client.client import ClobClient
+from poly_web3 import RELAYER_URL, PolyWeb3Service
+
+dotenv.load_dotenv()
+
+# Initialize ClobClient
+host = "https://clob.polymarket.com"
+chain_id = 137  # Polygon mainnet
+client = ClobClient(
+    host,
+    key=os.getenv("POLY_API_KEY"),
+    chain_id=chain_id,
+    signature_type=1,  # Proxy wallet type
+    funder=os.getenv("POLYMARKET_PROXY_ADDRESS"),
+)
+
+client.set_api_creds(client.create_or_derive_api_creds())
+
+# Initialize RelayerClient
+relayer_client = RelayClient(
+    RELAYER_URL,
+    chain_id,
+    os.getenv("POLY_API_KEY"),
+    BuilderConfig(
+        local_builder_creds=BuilderApiKeyCreds(
+            key=os.getenv("BUILDER_KEY"),
+            secret=os.getenv("BUILDER_SECRET"),
+            passphrase=os.getenv("BUILDER_PASSPHRASE"),
+        )
+    ),
+)
+
+# Create service instance
+service = PolyWeb3Service(clob_client=client, relayer_client=relayer_client)
+
+# Execute redeem operation
+condition_id = "0xc3df016175463c44f9c9f98bddaa3bf3daaabb14b069fb7869621cffe73ddd1c"
+redeem_result = service.redeem(condition_id=condition_id)
+print(f"Redeem result: {redeem_result}")
+```
+
+### Optional - Query Operations
+
+Before executing redeem, you can optionally check the condition status and query redeemable balances:
+
+```python
+# Check if condition is resolved
+condition_id = "0xc3df016175463c44f9c9f98bddaa3bf3daaabb14b069fb7869621cffe73ddd1c"
+can_redeem = service.is_condition_resolved(condition_id)
+
+# Get redeemable indexes and balances
+redeem_balance = service.get_redeemable_index_and_balance(
+    condition_id, owner=client.builder.funder
+)
+
+print(f"Can redeem: {can_redeem}")
+print(f"Redeemable balance: {redeem_balance}")
+```
+
+## API Documentation
+
+### PolyWeb3Service
+
+The main service class that automatically selects the appropriate service implementation based on wallet type.
+
+#### Methods
+
+##### `is_condition_resolved(condition_id: str) -> bool`
+
+Check if the specified condition is resolved.
+
+**Parameters:**
+- `condition_id` (str): Condition ID (32-byte hexadecimal string)
+
+**Returns:**
+- `bool`: Returns `True` if the condition is resolved, otherwise `False`
+
+##### `get_winning_indexes(condition_id: str) -> list[int]`
+
+Get the list of winning indexes.
+
+**Parameters:**
+- `condition_id` (str): Condition ID
+
+**Returns:**
+- `list[int]`: List of winning indexes
+
+##### `get_redeemable_index_and_balance(condition_id: str, owner: str) -> list[tuple]`
+
+Get redeemable indexes and balances for the specified address.
+
+**Parameters:**
+- `condition_id` (str): Condition ID
+- `owner` (str): Wallet address
+
+**Returns:**
+- `list[tuple]`: List of tuples containing (index, balance), balance is in USDC units
+
+##### `redeem(condition_id: str, neg_risk: bool = False, redeem_amounts: list[int] | None = None)`
+
+Execute redeem operation.
+
+**Parameters:**
+- `condition_id` (str): Condition ID
+- `neg_risk` (bool): Whether it's a negative risk redeem, defaults to `False`
+- `redeem_amounts` (list[int] | None): Amount list for negative risk redeem, must contain 2 elements
+
+**Returns:**
+- `dict`: Transaction result containing transaction status and related information
+
+**Examples:**
+
+```python
+# Standard CTF redeem
+result = service.redeem(condition_id="0x...")
+
+# Negative risk redeem
+result = service.redeem(
+    condition_id="0x...",
+    neg_risk=True,
+    redeem_amounts=[1000000, 2000000]  # Amounts in smallest unit (6 decimal places)
+)
+```
+
+## Project Structure
+
+```
+poly_web3/
+├── __init__.py              # Main entry point, exports PolyWeb3Service
+├── const.py                 # Constant definitions (contract addresses, ABIs, etc.)
+├── schema.py                # Data models (WalletType, etc.)
+├── signature/               # Signature-related modules
+│   ├── build.py            # Proxy wallet derivation and struct hashing
+│   ├── hash_message.py     # Message hashing
+│   └── secp256k1.py        # secp256k1 signing
+└── web3_service/           # Web3 service implementations
+    ├── base.py             # Base service class
+    ├── proxy_service.py    # Proxy wallet service (✅ Implemented)
+    ├── eoa_service.py      # EOA wallet service (🚧 Under development)
+    └── safe_service.py     # Safe wallet service (🚧 Under development)
+```
+
+## Notes
+
+1. **Environment Variable Security**: Make sure `.env` file is added to `.gitignore`, do not commit sensitive information to the code repository
+2. **Network Support**: Currently mainly supports Polygon mainnet (chain_id: 137), Amoy testnet may have limited functionality
+3. **Wallet Type**: **Currently only Proxy wallet is supported** (signature_type: 1), Safe and EOA wallet redeem functionality is under development
+4. **Gas Fees**: Transactions are executed through Relayer, gas fees are handled by the Relayer
+
+## Development
+
+### Install Development Dependencies
+
+```bash
+uv pip install -e ".[dev]"
+```
+
+### Run Examples
+
+```bash
+python examples/example_redeem.py
+```
+
+### Contributing
+
+We welcome all forms of contributions! If you'd like to:
+
+- Implement Safe or EOA wallet support
+- Fix bugs or improve existing functionality
+- Add new features or improve documentation
+- Make suggestions or report issues
+
+Please feel free to submit an Issue or Pull Request. Your contributions will help make this project better!
+
+## License
+
+MIT
+
+## Author
+
+PinBar
+
+## Related Links
+
+- [Polymarket](https://polymarket.com/)
+- [Polygon Network](https://polygon.technology/)

poly_web3-0.0.1.dist-info/RECORD

@@ -0,0 +1,17 @@
+examples/example_redeem.py,sha256=2KxsDjEtFrm9eo8Fme0CVAQ3NDu24G0Gfgwk4GdbzSo,1807
+poly_web3/__init__.py,sha256=sOPcaBjGctd_wT-UjztKq8rvcYBRA_HGhCr7rLXJOPM,1055
+poly_web3/const.py,sha256=VhH-UdsHN2DO993f60vnO093vSHAbaDwd6UIxb-GMuI,5091
+poly_web3/schema.py,sha256=sxZOzYglLLyQLwbSlQGpQzQ3IB7R059XQzJAO9T5frg,457
+poly_web3/signature/__init__.py,sha256=g5z1cPO_o-LPdvKb3VQu4aEcpJMMjJW-a9h9Mo6qczo,129
+poly_web3/signature/build.py,sha256=iSOzrMQOte6NWA981gQYPkCtRSoXhlFEcmV0bI7XMrA,3727
+poly_web3/signature/hash_message.py,sha256=IYCtqdV9HKE6bG6DZXt3wedrrXUn8KQ4RBgcqZq45aI,1367
+poly_web3/signature/secp256k1.py,sha256=AGpItsDFTAJR9ZpAfyC26llKaNmIfpD8v6HM3qqMAIA,1557
+poly_web3/web3_service/__init__.py,sha256=pxW7XqlSDZeoYc3ohwCcdtd_9aK3gJBIQ2ANXwHXUcE,324
+poly_web3/web3_service/base.py,sha256=5lfTKubdazwSNcG1o6Q0oTM6JM4-kgtzWkfohR3dBkI,4909
+poly_web3/web3_service/eoa_service.py,sha256=MmwaAmpD_WLk4M-2w99_F7iHTZ-pKtAnPw4m5x2h6CA,446
+poly_web3/web3_service/proxy_service.py,sha256=qIhBqa8ESSTH0e5W9WVvqLPVpJpEM5sYeRLrkHLvC1Y,4760
+poly_web3/web3_service/safe_service.py,sha256=KPmToVjqxFqFhFrDbY0hfR3Z00Alu9w31QKMyyluzX8,449
+poly_web3-0.0.1.dist-info/METADATA,sha256=3hej2oW7wH7z9KGMAEPW2UrmnirviY6ra__cJjbgAMI,8914
+poly_web3-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+poly_web3-0.0.1.dist-info/top_level.txt,sha256=wW40wsocHfhFgqSWWvYWrhwKGQU5IWkhyaz5J90vmHo,19
+poly_web3-0.0.1.dist-info/RECORD,,

poly_web3-0.0.1.dist-info/WHEEL

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

poly_web3-0.0.1.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+examples
+poly_web3