Etherdrake
651 lines
13 KiB
Markdown
651 lines
13 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.
|
|
|
|
# L2 Methods
|
|
|
|
> These methods require user API credentials (L2 headers). Use these for placing trades and managing user's positions.
|
|
|
|
***
|
|
|
|
## Client Initialization
|
|
|
|
L2 methods require the client to initialize with the signer, signatureType, user API credentials, and funder.
|
|
|
|
<Tabs>
|
|
<Tab title="TypeScript">
|
|
```typescript theme={null}
|
|
import { ClobClient } from "@polymarket/clob-client";
|
|
import { Wallet } from "ethers";
|
|
|
|
const signer = new Wallet(process.env.PRIVATE_KEY)
|
|
|
|
const apiCreds = {
|
|
apiKey: process.env.API_KEY,
|
|
secret: process.env.SECRET,
|
|
passphrase: process.env.PASSPHRASE,
|
|
};
|
|
|
|
const client = new ClobClient(
|
|
"https://clob.polymarket.com",
|
|
137,
|
|
signer,
|
|
apiCreds,
|
|
2, // Deployed Safe proxy wallet
|
|
process.env.FUNDER_ADDRESS // Address of deployed Safe proxy wallet
|
|
);
|
|
|
|
// Ready to send authenticated requests to the CLOB API!
|
|
const order = await client.postOrder(signedOrder);
|
|
```
|
|
</Tab>
|
|
|
|
<Tab title="Python">
|
|
```python theme={null}
|
|
from py_clob_client.client import ClobClient
|
|
from py_clob_client.clob_types import ApiCreds
|
|
import os
|
|
|
|
api_creds = ApiCreds(
|
|
api_key=os.getenv("API_KEY"),
|
|
api_secret=os.getenv("SECRET"),
|
|
api_passphrase=os.getenv("PASSPHRASE")
|
|
)
|
|
|
|
client = ClobClient(
|
|
host="https://clob.polymarket.com",
|
|
chain_id=137,
|
|
key=os.getenv("PRIVATE_KEY"),
|
|
creds=api_creds,
|
|
signature_type=2, # Deployed Safe proxy wallet
|
|
funder=os.getenv("FUNDER_ADDRESS") # Address of deployed Safe proxy wallet
|
|
)
|
|
|
|
# Ready to send authenticated requests to the CLOB API!
|
|
order = await client.post_order(signed_order)
|
|
```
|
|
</Tab>
|
|
</Tabs>
|
|
|
|
***
|
|
|
|
## Order Creation and Management
|
|
|
|
***
|
|
|
|
### createAndPostOrder()
|
|
|
|
A convenience method that creates, prompts signature, and posts an order in a single call.
|
|
Use when you want to buy/sell at a specific price and can wait.
|
|
|
|
```typescript Signature theme={null}
|
|
async createAndPostOrder(
|
|
userOrder: UserOrder,
|
|
options?: Partial<CreateOrderOptions>,
|
|
orderType?: OrderType.GTC | OrderType.GTD, // Defaults to GTC
|
|
): Promise<OrderResponse>
|
|
```
|
|
|
|
```typescript Params theme={null}
|
|
interface UserOrder {
|
|
tokenID: string;
|
|
price: number;
|
|
size: number;
|
|
side: Side;
|
|
feeRateBps?: number;
|
|
nonce?: number;
|
|
expiration?: number;
|
|
taker?: string;
|
|
}
|
|
|
|
type CreateOrderOptions = {
|
|
tickSize: TickSize;
|
|
negRisk?: boolean;
|
|
}
|
|
|
|
type TickSize = "0.1" | "0.01" | "0.001" | "0.0001";
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
interface OrderResponse {
|
|
success: boolean;
|
|
errorMsg: string;
|
|
orderID: string;
|
|
transactionsHashes: string[];
|
|
status: string;
|
|
takingAmount: string;
|
|
makingAmount: string;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
### createAndPostMarketOrder()
|
|
|
|
A convenience method that creates, prompts signature, and posts an order in a single call.
|
|
Use when you want to buy/sell right now at whatever the market price is.
|
|
|
|
```typescript Signature theme={null}
|
|
async createAndPostMarketOrder(
|
|
userMarketOrder: UserMarketOrder,
|
|
options?: Partial<CreateOrderOptions>,
|
|
orderType?: OrderType.FOK | OrderType.FAK, // Defaults to FOK
|
|
): Promise<OrderResponse>
|
|
```
|
|
|
|
```typescript Params theme={null}
|
|
interface UserMarketOrder {
|
|
tokenID: string;
|
|
amount: number;
|
|
side: Side;
|
|
price?: number;
|
|
feeRateBps?: number;
|
|
nonce?: number;
|
|
taker?: string;
|
|
orderType?: OrderType.FOK | OrderType.FAK;
|
|
}
|
|
|
|
type CreateOrderOptions = {
|
|
tickSize: TickSize;
|
|
negRisk?: boolean;
|
|
}
|
|
|
|
type TickSize = "0.1" | "0.01" | "0.001" | "0.0001";
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
interface OrderResponse {
|
|
success: boolean;
|
|
errorMsg: string;
|
|
orderID: string;
|
|
transactionsHashes: string[];
|
|
status: string;
|
|
takingAmount: string;
|
|
makingAmount: string;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
### postOrder()
|
|
|
|
Posts a pre-signed and created order to the CLOB.
|
|
|
|
```typescript Signature theme={null}
|
|
async postOrder(
|
|
order: SignedOrder,
|
|
orderType?: OrderType, // Defaults to GTC
|
|
postOnly?: boolean, // Defaults to false
|
|
): Promise<OrderResponse>
|
|
```
|
|
|
|
```typescript Params theme={null}
|
|
order: SignedOrder // Pre-signed order from createOrder() or createMarketOrder()
|
|
orderType?: OrderType // Optional, defaults to GTC
|
|
postOnly?: boolean // Optional, defaults to false
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
interface OrderResponse {
|
|
success: boolean;
|
|
errorMsg: string;
|
|
orderID: string;
|
|
transactionsHashes: string[];
|
|
status: string;
|
|
takingAmount: string;
|
|
makingAmount: string;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
### postOrders()
|
|
|
|
Posts up to 15 pre-signed and created orders in a single batch.
|
|
|
|
```typescript theme={null}
|
|
async postOrders(
|
|
args: PostOrdersArgs[],
|
|
): Promise<OrderResponse[]>
|
|
```
|
|
|
|
```typescript Params theme={null}
|
|
interface PostOrdersArgs {
|
|
order: SignedOrder;
|
|
orderType: OrderType;
|
|
postOnly?: boolean; // Defaults to false
|
|
}
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
OrderResponse[] // Array of OrderResponse objects
|
|
|
|
interface OrderResponse {
|
|
success: boolean;
|
|
errorMsg: string;
|
|
orderID: string;
|
|
transactionsHashes: string[];
|
|
status: string;
|
|
takingAmount: string;
|
|
makingAmount: string;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
### cancelOrder()
|
|
|
|
Cancels a single open order.
|
|
|
|
```typescript Signature theme={null}
|
|
async cancelOrder(orderID: string): Promise<CancelOrdersResponse>
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
interface CancelOrdersResponse {
|
|
canceled: string[];
|
|
not_canceled: Record<string, any>;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
### cancelOrders()
|
|
|
|
Cancels multiple orders in a single batch.
|
|
|
|
```typescript Signature theme={null}
|
|
async cancelOrders(orderIDs: string[]): Promise<CancelOrdersResponse>
|
|
```
|
|
|
|
```typescript Params theme={null}
|
|
orderIDs: string[];
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
interface CancelOrdersResponse {
|
|
canceled: string[];
|
|
not_canceled: Record<string, any>;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
### cancelAll()
|
|
|
|
Cancels all open orders.
|
|
|
|
```typescript Signature theme={null}
|
|
async cancelAll(): Promise<CancelResponse>
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
interface CancelOrdersResponse {
|
|
canceled: string[];
|
|
not_canceled: Record<string, any>;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
### cancelMarketOrders()
|
|
|
|
Cancels all open orders for a specific market.
|
|
|
|
```typescript Signature theme={null}
|
|
async cancelMarketOrders(
|
|
payload: OrderMarketCancelParams
|
|
): Promise<CancelOrdersResponse>
|
|
```
|
|
|
|
```typescript Parameters theme={null}
|
|
interface OrderMarketCancelParams {
|
|
market?: string;
|
|
asset_id?: string;
|
|
}
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
interface CancelOrdersResponse {
|
|
canceled: string[];
|
|
not_canceled: Record<string, any>;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
## Order and Trade Queries
|
|
|
|
***
|
|
|
|
### getOrder()
|
|
|
|
Get details for a specific order.
|
|
|
|
```typescript Signature theme={null}
|
|
async getOrder(orderID: string): Promise<OpenOrder>
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
interface OpenOrder {
|
|
id: string;
|
|
status: string;
|
|
owner: string;
|
|
maker_address: string;
|
|
market: string;
|
|
asset_id: string;
|
|
side: string;
|
|
original_size: string;
|
|
size_matched: string;
|
|
price: string;
|
|
associate_trades: string[];
|
|
outcome: string;
|
|
created_at: number;
|
|
expiration: string;
|
|
order_type: string;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
### getOpenOrders()
|
|
|
|
Get all your open orders.
|
|
|
|
```typescript Signature theme={null}
|
|
async getOpenOrders(
|
|
params?: OpenOrderParams,
|
|
only_first_page?: boolean,
|
|
): Promise<OpenOrdersResponse>
|
|
```
|
|
|
|
```typescript Params theme={null}
|
|
interface OpenOrderParams {
|
|
id?: string; // Order ID
|
|
market?: string; // Market condition ID
|
|
asset_id?: string; // Token ID
|
|
}
|
|
|
|
only_first_page?: boolean // Defaults to false
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
type OpenOrdersResponse = OpenOrder[];
|
|
|
|
interface OpenOrder {
|
|
id: string;
|
|
status: string;
|
|
owner: string;
|
|
maker_address: string;
|
|
market: string;
|
|
asset_id: string;
|
|
side: string;
|
|
original_size: string;
|
|
size_matched: string;
|
|
price: string;
|
|
associate_trades: string[];
|
|
outcome: string;
|
|
created_at: number;
|
|
expiration: string;
|
|
order_type: string;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
### getTrades()
|
|
|
|
Get your trade history (filled orders).
|
|
|
|
```typescript Signature theme={null}
|
|
async getTrades(
|
|
params?: TradeParams,
|
|
only_first_page?: boolean,
|
|
): Promise<Trade[]>
|
|
```
|
|
|
|
```typescript Params theme={null}
|
|
interface TradeParams {
|
|
id?: string;
|
|
maker_address?: string;
|
|
market?: string;
|
|
asset_id?: string;
|
|
before?: string;
|
|
after?: string;
|
|
}
|
|
|
|
only_first_page?: boolean // Defaults to false
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
interface Trade {
|
|
id: string;
|
|
taker_order_id: string;
|
|
market: string;
|
|
asset_id: string;
|
|
side: Side;
|
|
size: string;
|
|
fee_rate_bps: string;
|
|
price: string;
|
|
status: string;
|
|
match_time: string;
|
|
last_update: string;
|
|
outcome: string;
|
|
bucket_index: number;
|
|
owner: string;
|
|
maker_address: string;
|
|
maker_orders: MakerOrder[];
|
|
transaction_hash: string;
|
|
trader_side: "TAKER" | "MAKER";
|
|
}
|
|
|
|
interface MakerOrder {
|
|
order_id: string;
|
|
owner: string;
|
|
maker_address: string;
|
|
matched_amount: string;
|
|
price: string;
|
|
fee_rate_bps: string;
|
|
asset_id: string;
|
|
outcome: string;
|
|
side: Side;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
### getTradesPaginated()
|
|
|
|
Get trade history with pagination for large result sets.
|
|
|
|
```typescript Signature theme={null}
|
|
async getTradesPaginated(
|
|
params?: TradeParams,
|
|
): Promise<TradesPaginatedResponse>
|
|
```
|
|
|
|
```typescript Params theme={null}
|
|
interface TradeParams {
|
|
id?: string;
|
|
maker_address?: string;
|
|
market?: string;
|
|
asset_id?: string;
|
|
before?: string;
|
|
after?: string;
|
|
}
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
interface TradesPaginatedResponse {
|
|
trades: Trade[];
|
|
limit: number;
|
|
count: number;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
## Balance and Allowances
|
|
|
|
***
|
|
|
|
### getBalanceAllowance()
|
|
|
|
Get your balance and allowance for specific tokens.
|
|
|
|
```typescript Signature theme={null}
|
|
async getBalanceAllowance(
|
|
params?: BalanceAllowanceParams
|
|
): Promise<BalanceAllowanceResponse>
|
|
```
|
|
|
|
```typescript Params theme={null}
|
|
interface BalanceAllowanceParams {
|
|
asset_type: AssetType;
|
|
token_id?: string;
|
|
}
|
|
|
|
enum AssetType {
|
|
COLLATERAL = "COLLATERAL",
|
|
CONDITIONAL = "CONDITIONAL",
|
|
}
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
interface BalanceAllowanceResponse {
|
|
balance: string;
|
|
allowance: string;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
### updateBalanceAllowance()
|
|
|
|
Updates the cached balance and allowance for specific tokens.
|
|
|
|
```typescript Signature theme={null}
|
|
async updateBalanceAllowance(
|
|
params?: BalanceAllowanceParams
|
|
): Promise<void>
|
|
```
|
|
|
|
```typescript Params theme={null}
|
|
interface BalanceAllowanceParams {
|
|
asset_type: AssetType;
|
|
token_id?: string;
|
|
}
|
|
|
|
enum AssetType {
|
|
COLLATERAL = "COLLATERAL",
|
|
CONDITIONAL = "CONDITIONAL",
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
## API Key Management (L2)
|
|
|
|
### getApiKeys()
|
|
|
|
Get all API keys associated with your account.
|
|
|
|
```typescript Signature theme={null}
|
|
async getApiKeys(): Promise<ApiKeysResponse>
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
interface ApiKeysResponse {
|
|
apiKeys: ApiKeyCreds[];
|
|
}
|
|
|
|
interface ApiKeyCreds {
|
|
key: string;
|
|
secret: string;
|
|
passphrase: string;
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
### deleteApiKey()
|
|
|
|
Deletes (revokes) the currently authenticated API key.
|
|
|
|
**TypeScript Signature:**
|
|
|
|
```typescript theme={null}
|
|
async deleteApiKey(): Promise<any>
|
|
```
|
|
|
|
***
|
|
|
|
## Notifications
|
|
|
|
***
|
|
|
|
### getNotifications()
|
|
|
|
Retrieves all event notifications for the L2 authenticated user.
|
|
Records are removed automatically after 48 hours or if manually removed via dropNotifications().
|
|
|
|
```typescript Signature theme={null}
|
|
public async getNotifications(): Promise<Notification[]>
|
|
```
|
|
|
|
```typescript Response theme={null}
|
|
interface Notification {
|
|
id: number; // Unique notification ID
|
|
owner: string; // User's L2 credential apiKey or empty string for global notifications
|
|
payload: any; // Type-specific payload data
|
|
timestamp?: number; // Unix timestamp
|
|
type: number; // Notification type (see type mapping below)
|
|
}
|
|
```
|
|
|
|
**Notification Type Mapping**
|
|
|
|
| Name | Value | Description |
|
|
| ------------------ | ----- | ---------------------------------------- |
|
|
| Order Cancellation | 1 | User's order was canceled |
|
|
| Order Fill | 2 | User's order was filled (maker or taker) |
|
|
| Market Resolved | 4 | Market was resolved |
|
|
|
|
***
|
|
|
|
### dropNotifications()
|
|
|
|
Mark notifications as read/dismissed.
|
|
|
|
```typescript Signature theme={null}
|
|
public async dropNotifications(params?: DropNotificationParams): Promise<void>
|
|
```
|
|
|
|
```typescript Params theme={null}
|
|
interface DropNotificationParams {
|
|
ids: string[]; // Array of notification IDs to mark as read
|
|
}
|
|
```
|
|
|
|
***
|
|
|
|
## See Also
|
|
|
|
<CardGroup cols={2}>
|
|
<Card title="Understand CLOB Authentication" icon="shield" href="/developers/CLOB/authentication">
|
|
Deep dive into L1 and L2 authentication
|
|
</Card>
|
|
|
|
<Card title="Public Methods" icon="globe" href="/developers/CLOB/clients/methods-l2">
|
|
Access market data, orderbooks, and prices.
|
|
</Card>
|
|
|
|
<Card title="L1 Methods" icon="lock" href="/developers/CLOB/clients/methods-l2">
|
|
Private key authentication to create or derive API keys (L2 headers)
|
|
</Card>
|
|
|
|
<Card title="Web Socket API" icon="hammer" href="/developers/CLOB/websocket/wss-overview">
|
|
Real-time market data streaming
|
|
</Card>
|
|
</CardGroup>
|