polymarket-apis 0.2.2__py3-none-any.whl

polymarket_apis/utilities/order_builder/builder.py

@@ -0,0 +1,240 @@
+from py_order_utils.builders import OrderBuilder as UtilsOrderBuilder
+from py_order_utils.model import (
+    BUY as UTILS_BUY,
+)
+from py_order_utils.model import (
+    EOA,
+    OrderData,
+    SignedOrder,
+)
+from py_order_utils.model import (
+    SELL as UTILS_SELL,
+)
+from py_order_utils.signer import Signer as UtilsSigner
+
+from ...types.clob_types import (
+    CreateOrderOptions,
+    MarketOrderArgs,
+    OrderArgs,
+    OrderSummary,
+    OrderType,
+    RoundConfig,
+    TickSize,
+)
+from ..config import get_contract_config
+from ..constants import BUY, SELL
+from ..exceptions import LiquidityError
+from ..signing.signer import Signer
+from .helpers import (
+    decimal_places,
+    round_down,
+    round_normal,
+    round_up,
+    to_token_decimals,
+)
+
+ROUNDING_CONFIG: dict[TickSize, RoundConfig] = {
+    "0.1": RoundConfig(price=1, size=2, amount=3),
+    "0.01": RoundConfig(price=2, size=2, amount=4),
+    "0.001": RoundConfig(price=3, size=2, amount=5),
+    "0.0001": RoundConfig(price=4, size=2, amount=6),
+}
+
+
+class OrderBuilder:
+    def __init__(self, signer: Signer, sig_type=None, funder=None):
+        self.signer = signer
+
+        # Signature type used sign orders, defaults to EOA type
+        self.sig_type = sig_type if sig_type is not None else EOA
+
+        # Address which holds funds to be used.
+        # Used for Polymarket proxy wallets and other smart contract wallets
+        # Defaults to the address of the signer
+        self.funder = funder if funder is not None else self.signer.address()
+
+    def get_order_amounts(
+            self, side: str, size: float, price: float, round_config: RoundConfig,
+    ):
+        raw_price = round_normal(price, round_config.price)
+
+        if side == BUY:
+            raw_taker_amt = round_down(size, round_config.size)
+
+            raw_maker_amt = raw_taker_amt * raw_price
+            if decimal_places(raw_maker_amt) > round_config.amount:
+                raw_maker_amt = round_up(raw_maker_amt, round_config.amount + 4)
+                if decimal_places(raw_maker_amt) > round_config.amount:
+                    raw_maker_amt = round_down(raw_maker_amt, round_config.amount)
+
+            maker_amount = to_token_decimals(raw_maker_amt)
+            taker_amount = to_token_decimals(raw_taker_amt)
+
+            return UTILS_BUY, maker_amount, taker_amount
+        if side == SELL:
+            raw_maker_amt = round_down(size, round_config.size)
+
+            raw_taker_amt = raw_maker_amt * raw_price
+            if decimal_places(raw_taker_amt) > round_config.amount:
+                raw_taker_amt = round_up(raw_taker_amt, round_config.amount + 4)
+                if decimal_places(raw_taker_amt) > round_config.amount:
+                    raw_taker_amt = round_down(raw_taker_amt, round_config.amount)
+
+            maker_amount = to_token_decimals(raw_maker_amt)
+            taker_amount = to_token_decimals(raw_taker_amt)
+
+            return UTILS_SELL, maker_amount, taker_amount
+        msg = f"order_args.side must be '{BUY}' or '{SELL}'"
+        raise ValueError(msg)
+
+    def get_market_order_amounts(
+            self, side: str, amount: float, price: float, round_config: RoundConfig,
+    ):
+        raw_price = round_normal(price, round_config.price)
+
+        if side == BUY:
+            raw_maker_amt = round_down(amount, round_config.size)
+            raw_taker_amt = raw_maker_amt / raw_price
+            if decimal_places(raw_taker_amt) > round_config.amount:
+                raw_taker_amt = round_up(raw_taker_amt, round_config.amount + 4)
+                if decimal_places(raw_taker_amt) > round_config.amount:
+                    raw_taker_amt = round_down(raw_taker_amt, round_config.amount)
+
+            maker_amount = to_token_decimals(raw_maker_amt)
+            taker_amount = to_token_decimals(raw_taker_amt)
+
+            return UTILS_BUY, maker_amount, taker_amount
+
+        if side == SELL:
+            raw_maker_amt = round_down(amount, round_config.size)
+
+            raw_taker_amt = raw_maker_amt * raw_price
+            if decimal_places(raw_taker_amt) > round_config.amount:
+                raw_taker_amt = round_up(raw_taker_amt, round_config.amount + 4)
+                if decimal_places(raw_taker_amt) > round_config.amount:
+                    raw_taker_amt = round_down(raw_taker_amt, round_config.amount)
+
+            maker_amount = to_token_decimals(raw_maker_amt)
+            taker_amount = to_token_decimals(raw_taker_amt)
+
+            return UTILS_SELL, maker_amount, taker_amount
+        msg = f"order_args.side must be '{BUY}' or '{SELL}'"
+        raise ValueError(msg)
+
+    def create_order(
+            self, order_args: OrderArgs, options: CreateOrderOptions,
+    ) -> SignedOrder:
+        """Creates and signs an order."""
+        side, maker_amount, taker_amount = self.get_order_amounts(
+            order_args.side,
+            order_args.size,
+            order_args.price,
+            ROUNDING_CONFIG[options.tick_size],
+        )
+
+        data = OrderData(
+            maker=self.funder,
+            taker=order_args.taker,
+            tokenId=order_args.token_id,
+            makerAmount=str(maker_amount),
+            takerAmount=str(taker_amount),
+            side=side,
+            feeRateBps=str(order_args.fee_rate_bps),
+            nonce=str(order_args.nonce),
+            signer=self.signer.address(),
+            expiration=str(order_args.expiration),
+            signatureType=self.sig_type,
+        )
+
+        contract_config = get_contract_config(
+            self.signer.get_chain_id(), options.neg_risk,
+        )
+
+        order_builder = UtilsOrderBuilder(
+            contract_config.exchange,
+            self.signer.get_chain_id(),
+            UtilsSigner(key=self.signer.private_key),
+        )
+
+        return order_builder.build_signed_order(data)
+
+    def create_market_order(
+            self, order_args: MarketOrderArgs, options: CreateOrderOptions,
+    ) -> SignedOrder:
+        """Creates and signs a market order."""
+        side, maker_amount, taker_amount = self.get_market_order_amounts(
+            order_args.side,
+            order_args.amount,
+            order_args.price,
+            ROUNDING_CONFIG[options.tick_size],
+        )
+
+        data = OrderData(
+            maker=self.funder,
+            taker=order_args.taker,
+            tokenId=order_args.token_id,
+            makerAmount=str(maker_amount),
+            takerAmount=str(taker_amount),
+            side=side,
+            feeRateBps=str(order_args.fee_rate_bps),
+            nonce=str(order_args.nonce),
+            signer=self.signer.address(),
+            expiration="0",
+            signatureType=self.sig_type,
+        )
+
+        contract_config = get_contract_config(
+            self.signer.get_chain_id(), options.neg_risk,
+        )
+
+        order_builder = UtilsOrderBuilder(
+            contract_config.exchange,
+            self.signer.get_chain_id(),
+            UtilsSigner(key=self.signer.private_key),
+        )
+
+        return order_builder.build_signed_order(data)
+
+    def calculate_buy_market_price(
+            self,
+            asks: list[OrderSummary], # expected to be sorted from worst to best price (high to low)
+            amount_to_match: float, # in usdc
+            order_type: OrderType,
+    ) -> float:
+        if not asks:
+            msg = "No ask orders available"
+            raise LiquidityError(msg)
+
+        sum = 0
+        for p in reversed(asks):
+            sum += float(p.size) * float(p.price)
+            if sum >= amount_to_match:
+                return float(p.price)
+
+        if order_type == OrderType.FOK:
+            msg = "no match"
+            raise ValueError(msg)
+
+        return float(asks[0].price)
+
+    def calculate_sell_market_price(
+            self,
+            bids: list[OrderSummary], # expected to be sorted from worst to best price (low to high)
+            amount_to_match: float, # in usdc
+            order_type: OrderType,
+    ) -> float:
+        if not bids:
+            msg = "No bid orders available"
+            raise LiquidityError(msg)
+
+        sum = 0
+        for p in reversed(bids):
+            sum += float(p.size)
+            if sum >= amount_to_match:
+                return float(p.price)
+
+        if order_type == OrderType.FOK:
+            msg = "no match"
+            raise ValueError(msg)
+
+        return float(bids[0].price)

polymarket_apis/utilities/order_builder/helpers.py

@@ -0,0 +1,61 @@
+import hashlib
+from decimal import Decimal
+from math import ceil, floor
+
+from ...types.clob_types import OrderBookSummary, TickSize
+
+
+def round_down(x: float, sig_digits: int) -> float:
+    return floor(x * (10**sig_digits)) / (10**sig_digits)
+
+
+def round_normal(x: float, sig_digits: int) -> float:
+    return round(x * (10**sig_digits)) / (10**sig_digits)
+
+
+def round_up(x: float, sig_digits: int) -> float:
+    return ceil(x * (10**sig_digits)) / (10**sig_digits)
+
+
+def to_token_decimals(x: float) -> int:
+    f = (10**6) * x
+    if decimal_places(f) > 0:
+        f = round_normal(f, 0)
+    return int(f)
+
+
+def decimal_places(x: float) -> int:
+    """
+    Returns the number of decimal places in a float.
+
+    Assumes x is always a finite, non-special value (not NaN or Infinity).
+    """
+    exponent = Decimal(str(x)).as_tuple().exponent
+    if not isinstance(exponent, int):
+        msg = "Input must be a finite float."
+        raise TypeError(msg)
+    return abs(exponent)
+
+
+
+def generate_orderbook_summary_hash(orderbook: OrderBookSummary) -> str:
+    """Compute hash while forcing empty string for hash field."""
+    server_hash = orderbook.hash
+    orderbook.hash = ""
+    computed_hash = hashlib.sha1(
+        str(orderbook.model_dump_json(by_alias=True)).encode("utf-8"),
+    ).hexdigest()
+    orderbook.hash = server_hash
+    return computed_hash
+
+
+def order_to_json(order, owner, order_type) -> dict:
+    return {"order": order.dict(), "owner": owner, "orderType": order_type.value}
+
+
+def is_tick_size_smaller(a: TickSize, b: TickSize) -> bool:
+    return float(a) < float(b)
+
+
+def price_valid(price: float, tick_size: TickSize) -> bool:
+    return float(tick_size) <= price <= 1 - float(tick_size)

polymarket_apis/utilities/signing/eip712.py

@@ -0,0 +1,28 @@
+from eth_utils import keccak
+from poly_eip712_structs import make_domain
+from py_order_utils.utils import prepend_zx
+
+from ..signing.model import ClobAuth
+from ..signing.signer import Signer
+
+CLOB_DOMAIN_NAME = "ClobAuthDomain"
+CLOB_VERSION = "1"
+MSG_TO_SIGN = "This message attests that I control the given wallet"
+
+
+def get_clob_auth_domain(chain_id: int):
+    return make_domain(name=CLOB_DOMAIN_NAME, version=CLOB_VERSION, chainId=chain_id)
+
+
+def sign_clob_auth_message(signer: Signer, timestamp: int, nonce: int) -> str:
+    clob_auth_msg = ClobAuth(
+        address=signer.address(),
+        timestamp=str(timestamp),
+        nonce=nonce,
+        message=MSG_TO_SIGN,
+    )
+    chain_id = signer.get_chain_id()
+    auth_struct_hash = prepend_zx(
+        keccak(clob_auth_msg.signable_bytes(get_clob_auth_domain(chain_id))).hex(),
+    )
+    return prepend_zx(signer.sign(auth_struct_hash))

polymarket_apis/utilities/signing/hmac.py

@@ -0,0 +1,20 @@
+import base64
+import hashlib
+import hmac
+
+
+def build_hmac_signature(
+    secret: str, timestamp: str, method: str, request_path: str, body=None,
+):
+    """Creates an HMAC signature by signing a payload with the secret."""
+    base64_secret = base64.urlsafe_b64decode(secret)
+    message = str(timestamp) + str(method) + str(request_path)
+    if body:
+        # NOTE: Necessary to replace single quotes with double quotes
+        # to generate the same hmac message as go and typescript
+        message += str(body).replace("'", '"')
+
+    h = hmac.new(base64_secret, bytes(message, "utf-8"), hashlib.sha256)
+
+    # ensure base64 encoded
+    return (base64.urlsafe_b64encode(h.digest())).decode("utf-8")

polymarket_apis/utilities/signing/model.py

@@ -0,0 +1,8 @@
+from poly_eip712_structs import Address, EIP712Struct, String, Uint
+
+
+class ClobAuth(EIP712Struct):
+    address = Address()
+    timestamp = String()
+    nonce = Uint()
+    message = String()

polymarket_apis/utilities/signing/signer.py

@@ -0,0 +1,25 @@
+from eth_account import Account
+
+
+class Signer:
+    def __init__(self, private_key: str, chain_id: int):
+        if private_key is None:
+            msg = "private_key must not be None"
+            raise ValueError(msg)
+        if chain_id is None:
+            msg = "chain_id must not be None"
+            raise ValueError(msg)
+
+        self.private_key = private_key
+        self.account = Account.from_key(private_key)
+        self.chain_id = chain_id
+
+    def address(self):
+        return self.account.address
+
+    def get_chain_id(self):
+        return self.chain_id
+
+    def sign(self, message_hash):
+        """Signs a message hash."""
+        return Account.unsafe_sign_hash(message_hash, self.private_key).signature.hex()