C'est quoi, Polymarket ?

Polymarket est le plus grand marché de prévisions au monde, où les utilisateurs peuvent échanger la probabilité d'événements - des compétitions sportives aux élections politiques, des prix chiffrés de l'argent aux nouvelles scientifiques et technologiques. La manière dont la transaction a lieu est similaire à la « double puissance » : achète un jeton « oui » ou « non » pour un résultat donné et est récompensé si le résultat se produit.

Ses points forts sont les suivants :

• Totalement décentralisé.: Ouvert et transparent sur la base de la chaîne Polygon
• Découverte des prix en temps réel: Les prévisions du marché tendent à être plus précises que les sondages traditionnels
• API Ouvrir: Fournir une API complète des transactions pour soutenir les transactions automatisées

Préparations

Installer la Dépendance Python

Nous en avons besoin. py-clob-client Ce SDK officiel:

pip install py-clob-client requests python-dotenv

2. Accès aux portefeuilles et API Key

Polymark prend en charge deux types d'authentification :

• Portefeuille EOA(Payez à l'essence)
• Portefeuille mandataire(opération sans gaz)

Voici la façon la plus simple de démontrer -- le portefeuille de l'OEA :

1. Créer un portefeuille Polygon (recommandé avec MetaMask)
2. Dépôt USDC.e(pour le commerce) POL(pour le gaz)
3. Pour le portefeuille. Clé privée
4. Utilisation de SDK create_or_derive_api_creds() Méthode pour générer automatiquement des bons API

3. OpenClaw Environnement

OpenClaw exec L'outil exécute le code Python et est bien adapté pour exécuter ce script automatisé.

Code de base atteint

Base : Surveiller le marché + Inscription automatique

import os
import time
import requests
from py_clob_client.client import ClobClient
from py_clob_client.clob_types import OrderArgs, OrderType
from py_clob_client.order_builder.constants import BUY, SELL

HOST = "https://clob.polymarket.com"
CHAIN_ID = 137
PRIVATE_KEY = os.getenv("POLYMARKET_PRIVATE_KEY")
FUNDER_ADDRESS = os.getenv("POLYMARKET_FUNDER")

def init_client():
    temp_client = ClobClient(HOST, key=PRIVATE_KEY, chain_id=CHAIN_ID)
    api_creds = temp_client.create_or_derive_api_creds()
    client = ClobClient(HOST, key=PRIVATE_KEY, chain_id=CHAIN_ID, creds=api_creds, signature_type=0, funder=FUNDER_ADDRESS)
    return client

def get_markets(tag=None, limit=10):
    url = "https://gamma-api.polymarket.com/markets"
    params = {"active": "true", "closed": "false", "limit": limit}
    if tag:
        params["tagName"] = tag
    resp = requests.get(url, params=params)
    return resp.json()

def get_price(token_id):
    url = f"https://gamma-api.polymarket.com/markets/{token_id}/price"
    resp = requests.get(url)
    return resp.json()

def place_order(client, token_id, price, size, side=BUY):
    order = client.create_and_post_order(
        OrderArgs(token_id=token_id, price=price, size=size, side=side, order_type=OrderType.GTC),
        options={"tick_size": "0.01", "neg_risk": False}
    )
    return order

Progrès: Machine de stratégie de retour moyenne Personnes

L'idée centrale de cette stratégie est de l'acheter automatiquement lorsque les prix s'écartent de la moyenne et attendent le retour.

import logging
import time

logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

class MeanReversionBot:
    def __init__(self, client, token_id, threshold=0.1, size=10):
        self.client = client
        self.token_id = token_id
        self.threshold = threshold
        self.size = size
    
    def get_mid_price(self):
        data = get_price(self.token_id)
        return float(data.get("price", 0.5))
    
    def check_and_trade(self):
        mid_price = self.get_mid_price()
        logger.info(f"当前中间价: {mid_price}")
        
        if mid_price < 0.5 - self.threshold:
            logger.info(f"价格偏低，买入!")
            order = place_order(self.client, self.token_id, mid_price, self.size, BUY)
            logger.info(f"订单已下单: {order}")
        elif mid_price > 0.5 + self.threshold:
            logger.info(f"价格偏高，卖出!")
            order = place_order(self.client, self.token_id, mid_price, self.size, SELL)
            logger.info(f"订单已下单: {order}")
        else:
            logger.info("价格在合理区间，不交易")
    
    def run(self, interval=60):
        logger.info(f"机器人启动，监控 token: {self.token_id}")
        while True:
            try:
                self.check_and_trade()
            except Exception as e:
                logger.error(f"错误: {e}")
            time.sleep(interval)

if __name__ == "__main__":
    client = init_client()
    markets = get_markets(tag="politics", limit=1)
    if markets:
        token_id = markets[0]["clobTokenIds"][0]
        print(f"监控市场: {markets[0]['question']}")
        bot = MeanReversionBot(client, token_id, threshold=0.15, size=5)
        bot.run(interval=120)

Intégration OpenClaw

C'est très simple de faire fonctionner ce robot dans OpenClaw. Vous pouvez enregistrer le code ci-dessus comme polymarket_bot.py, puis exécuter dans OpenClaw:

运行 python polymarket_bot.py

Attention

Conseils pour les risques

• Volatilité du marché prévue, n'utilisez que les fonds qui sont abordables
• Il est recommandé de tester le réseau d'abord.
• Les transactions robotiques nécessitent une surveillance constante pour prévenir les extrêmes.

2. Restrictions des API

• Ouvrir l'API sans authentification
• Deal API a besoin de portefeuille et API Key
• Attention aux limites de vitesse.

Optimisation du gaz

• Le mode EOA nécessite un paiement POL Gaz
• Vous pouvez demander des portefeuilles proxy pour effectuer la transaction Gasless