Etherdrake
288 lines
9.1 KiB
Markdown
288 lines
9.1 KiB
Markdown
> ## Documentation Index
|
|
> Fetch the complete documentation index at: https://docs.polymarket.com/llms.txt
|
|
> Use this file to discover all available pages before exploring further.
|
|
|
|
# Quickstart
|
|
|
|
> Place your first order on Polymarket
|
|
|
|
This guide walks you through placing an order on Polymarket end-to-end.
|
|
|
|
<Steps>
|
|
<Step title="Install the SDK">
|
|
<CodeGroup>
|
|
```bash TypeScript theme={null}
|
|
npm install @polymarket/clob-client-v2 viem
|
|
```
|
|
|
|
```bash Python theme={null}
|
|
pip install py-clob-client-v2
|
|
```
|
|
|
|
```bash Rust theme={null}
|
|
cargo add polymarket_client_sdk_v2 --features clob
|
|
```
|
|
</CodeGroup>
|
|
</Step>
|
|
|
|
<Step title="Set Up Your Client">
|
|
Derive your API credentials and initialize the trading client. This example uses an EOA wallet (type `0`) — your wallet pays its own gas and acts as the funder:
|
|
|
|
<CodeGroup>
|
|
```typescript TypeScript theme={null}
|
|
import { ClobClient } from "@polymarket/clob-client-v2";
|
|
import { createWalletClient, http } from "viem";
|
|
import { privateKeyToAccount } from "viem/accounts";
|
|
|
|
const HOST = "https://clob.polymarket.com";
|
|
const CHAIN_ID = 137; // Polygon mainnet
|
|
const account = privateKeyToAccount(process.env.PRIVATE_KEY as `0x${string}`);
|
|
const signer = createWalletClient({ account, transport: http() });
|
|
|
|
// Derive API credentials
|
|
const tempClient = new ClobClient({ host: HOST, chain: CHAIN_ID, signer });
|
|
const apiCreds = await tempClient.createOrDeriveApiKey();
|
|
|
|
// Initialize trading client
|
|
const client = new ClobClient({
|
|
host: HOST,
|
|
chain: CHAIN_ID,
|
|
signer,
|
|
creds: apiCreds,
|
|
signatureType: 0, // EOA
|
|
funderAddress: account.address,
|
|
});
|
|
```
|
|
|
|
```python Python theme={null}
|
|
from py_clob_client_v2 import ClobClient
|
|
import os
|
|
|
|
host = "https://clob.polymarket.com"
|
|
chain = 137 # Polygon mainnet
|
|
private_key = os.getenv("PRIVATE_KEY")
|
|
|
|
# Derive API credentials
|
|
temp_client = ClobClient(host, key=private_key, chain_id=chain)
|
|
api_creds = temp_client.create_or_derive_api_key()
|
|
|
|
# Initialize trading client
|
|
client = ClobClient(
|
|
host,
|
|
key=private_key,
|
|
chain_id=chain,
|
|
creds=api_creds,
|
|
signature_type=0, # EOA
|
|
funder="YOUR_WALLET_ADDRESS"
|
|
)
|
|
```
|
|
|
|
```rust Rust theme={null}
|
|
use std::str::FromStr;
|
|
use polymarket_client_sdk_v2::POLYGON;
|
|
use polymarket_client_sdk_v2::auth::{LocalSigner, Signer};
|
|
use polymarket_client_sdk_v2::clob::{Client, Config};
|
|
|
|
let private_key = std::env::var("POLYMARKET_PRIVATE_KEY")?;
|
|
let signer = LocalSigner::from_str(&private_key)?
|
|
.with_chain_id(Some(POLYGON));
|
|
|
|
// Derive API credentials and initialize client (EOA by default)
|
|
let client = Client::new("https://clob.polymarket.com", Config::default())?
|
|
.authentication_builder(&signer)
|
|
.authenticate()
|
|
.await?;
|
|
```
|
|
</CodeGroup>
|
|
|
|
<Note>
|
|
If you have a Polymarket.com account, your funds are in a proxy wallet — use
|
|
signature type `1` or `2` instead. See [Signature
|
|
Types](/trading/overview#signature-types) for details.
|
|
</Note>
|
|
|
|
<Warning>
|
|
Before trading, your funder address needs **pUSD** (for buying outcome
|
|
tokens) and **POL** (for gas, if using EOA type `0`). Proxy wallet users
|
|
(types `1` and `2`) can use Polymarket's gasless relayer instead.
|
|
</Warning>
|
|
</Step>
|
|
|
|
<Step title="Place an Order">
|
|
Get a token ID from the [Markets API](/market-data/fetching-markets), then create and submit your order:
|
|
|
|
<CodeGroup>
|
|
```typescript TypeScript theme={null}
|
|
import { Side, OrderType } from "@polymarket/clob-client-v2";
|
|
|
|
const response = await client.createAndPostOrder(
|
|
{
|
|
tokenID: "YOUR_TOKEN_ID",
|
|
price: 0.5,
|
|
size: 10,
|
|
side: Side.BUY,
|
|
},
|
|
{
|
|
tickSize: "0.01",
|
|
negRisk: false, // Set to true for multi-outcome markets
|
|
},
|
|
OrderType.GTC,
|
|
);
|
|
|
|
console.log("Order ID:", response.orderID);
|
|
console.log("Status:", response.status);
|
|
```
|
|
|
|
```python Python theme={null}
|
|
from py_clob_client_v2 import OrderArgs, OrderType, PartialCreateOrderOptions
|
|
from py_clob_client_v2.order_builder.constants import BUY
|
|
|
|
response = client.create_and_post_order(
|
|
OrderArgs(
|
|
token_id="YOUR_TOKEN_ID",
|
|
price=0.50,
|
|
size=10,
|
|
side=BUY,
|
|
),
|
|
options=PartialCreateOrderOptions(
|
|
tick_size="0.01",
|
|
neg_risk=False, # Set to True for multi-outcome markets
|
|
),
|
|
order_type=OrderType.GTC
|
|
)
|
|
|
|
print("Order ID:", response["orderID"])
|
|
print("Status:", response["status"])
|
|
```
|
|
|
|
```rust Rust theme={null}
|
|
use polymarket_client_sdk_v2::clob::types::Side;
|
|
use polymarket_client_sdk_v2::types::dec;
|
|
|
|
let token_id = "YOUR_TOKEN_ID".parse()?;
|
|
|
|
// Tick size and neg risk are auto-fetched by the order builder
|
|
let order = client
|
|
.limit_order()
|
|
.token_id(token_id)
|
|
.price(dec!(0.50))
|
|
.size(dec!(10))
|
|
.side(Side::Buy)
|
|
.build()
|
|
.await?;
|
|
let signed_order = client.sign(&signer, order).await?;
|
|
let response = client.post_order(signed_order).await?;
|
|
|
|
println!("Order ID: {}", response.order_id);
|
|
println!("Status: {:?}", response.status);
|
|
```
|
|
</CodeGroup>
|
|
|
|
<Tip>
|
|
Look up a market's `tickSize` and `negRisk` values using the SDK's
|
|
`getTickSize()` and `getNegRisk()` methods, or from the market object returned
|
|
by the API.
|
|
</Tip>
|
|
</Step>
|
|
|
|
<Step title="Check Your Orders">
|
|
<CodeGroup>
|
|
```typescript TypeScript theme={null}
|
|
// View all open orders
|
|
const openOrders = await client.getOpenOrders();
|
|
console.log(`You have ${openOrders.length} open orders`);
|
|
|
|
// View your trade history
|
|
const trades = await client.getTrades();
|
|
console.log(`You've made ${trades.length} trades`);
|
|
|
|
// Cancel an order
|
|
await client.cancelOrder(response.orderID);
|
|
```
|
|
|
|
```python Python theme={null}
|
|
# View all open orders
|
|
open_orders = client.get_orders()
|
|
print(f"You have {len(open_orders)} open orders")
|
|
|
|
# View your trade history
|
|
trades = client.get_trades()
|
|
print(f"You've made {len(trades)} trades")
|
|
|
|
# Cancel an order
|
|
client.cancel(order_id=response["orderID"])
|
|
```
|
|
|
|
```rust Rust theme={null}
|
|
use polymarket_client_sdk_v2::clob::types::request::{OrdersRequest, TradesRequest};
|
|
|
|
// View all open orders
|
|
let open_orders = client.orders(&OrdersRequest::default(), None).await?;
|
|
println!("You have {} open orders", open_orders.data.len());
|
|
|
|
// View your trade history
|
|
let trades = client.trades(&TradesRequest::default(), None).await?;
|
|
println!("You've made {} trades", trades.data.len());
|
|
|
|
// Cancel an order
|
|
client.cancel_order(&response.order_id).await?;
|
|
```
|
|
</CodeGroup>
|
|
</Step>
|
|
</Steps>
|
|
|
|
***
|
|
|
|
## Troubleshooting
|
|
|
|
<AccordionGroup>
|
|
<Accordion title="L2 AUTH NOT AVAILABLE - Invalid Signature">
|
|
Wrong private key, signature type, or funder address for the derived API credentials.
|
|
|
|
* Check that `signatureType` matches your account type (`0`, `1`, `2`, or `3`)
|
|
* Ensure `funder` is correct for your wallet type
|
|
* Re-derive credentials with `createOrDeriveApiKey()` if unsure
|
|
</Accordion>
|
|
|
|
<Accordion title="Order rejected - insufficient balance">
|
|
Your funder address doesn't have enough tokens:
|
|
|
|
* **BUY orders**: need pUSD in your funder address
|
|
* **SELL orders**: need outcome tokens in your funder address
|
|
* Ensure you have more pUSD than what's committed in open orders
|
|
</Accordion>
|
|
|
|
<Accordion title="Order rejected - insufficient allowance">
|
|
You need to approve the Exchange contract to spend your tokens. This is
|
|
typically done through the Polymarket UI on your first trade, or using the CTF
|
|
contract's `setApprovalForAll()` method.
|
|
</Accordion>
|
|
|
|
<Accordion title="What is my funder address">
|
|
Your funder address is the wallet where your funds are held:
|
|
|
|
* **EOA (type 0)**: Your wallet address directly
|
|
* **Proxy wallet (type 1 or 2)**: Go to [polymarket.com/settings](https://polymarket.com/settings) and look for the wallet address in the profile dropdown
|
|
|
|
If the proxy wallet doesn't exist, log into Polymarket.com first (it's deployed on first login).
|
|
</Accordion>
|
|
|
|
<Accordion title="Blocked by Cloudflare or Geoblock">
|
|
You're trying to place a trade from a restricted region. See [Geographic Restrictions](/api-reference/geoblock) for details.
|
|
</Accordion>
|
|
</AccordionGroup>
|
|
|
|
***
|
|
|
|
## Next Steps
|
|
|
|
<CardGroup cols={2}>
|
|
<Card title="Create Orders" icon="plus" href="/trading/orders/create">
|
|
Order types, tick sizes, and error handling
|
|
</Card>
|
|
|
|
<Card title="Order Attribution" icon="tag" href="/trading/orders/attribution">
|
|
Attribute orders to your builder account for volume credit
|
|
</Card>
|
|
</CardGroup>
|