Polyoxide

https://docs.rs/polyoxide/0.12.1
Admin
Polyoxide is a unified Rust client for Polymarket APIs that combines CLOB trading, Gamma market...
Tokens:21,237
Snippets:189
Trust Score:9.1
Update:6 months ago
Show doc for...
Tokens:
Raw
### Getting Account Address

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Account.html

Retrieves the wallet address associated with the Account.

```rust
// Get the wallet address
println!("Address: {:?}", account.address());
```

--------------------------------

### Get Contracts for Chain

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/enum.Chain.html

Retrieves the associated contract addresses and ABIs for a specific Chain variant. This is essential for interacting with smart contracts on a particular network.

```rust
pub const fn contracts(&self) -> Contracts
```

--------------------------------

### Get Type ID of a Generic Type

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.CreateOrderParams.html

Gets the `TypeId` of a generic type `T`. This is part of the `Any` trait implementation.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Initialize and Use Polymarket Client

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/index.html

Demonstrates initializing the Polymarket client using environment variables and performing market data, user position, and order placement operations.

```rust
use polyoxide::prelude::*;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Load account from environment variables
    let account = Account::from_env()?;

    // Create unified client
    let polymarket = Polymarket::builder(account)
        .chain(Chain::PolygonMainnet)
        .build()?;

    // Use Gamma API to list markets
    let markets = polymarket.gamma.markets()
        .list()
        .open(true)
        .limit(10)
        .send()
        .await?;

    // Use Data API to get user positions
    let positions = polymarket.data
        .user("0x1234567890123456789012345678901234567890")
        .list_positions()
        .limit(10)
        .send()
        .await?;

    for position in &positions {
        println!("Position: {} - size: {}", position.title, position.size);
    }

    // Use CLOB API to place an order
    if let Some(first_market) = markets.first() {
        if let Some(token) = first_market.tokens.first() {
            let order_params = CreateOrderParams {
                token_id: token.token_id.clone(),
                price: 0.52,
                size: 100.0,
                side: OrderSide::Buy,
                expiration: None,
                order_type: OrderKind::Gtc,
                post_only: false,
                funder: None,
                signature_type: Some(SignatureType::PolyProxy),
            };

            let response = polymarket.clob.place_order(&order_params, None).await?;
            println!("Order placed: {:?}", response.order_id);
        }
    }

    Ok(())
}
```

--------------------------------

### PolymarketBuilder Implementation Methods

Source: https://docs.rs/polyoxide/0.12.1/src/polyoxide/lib.rs.html

Methods for initializing the builder and configuring client parameters.

```rust
#[cfg(all(feature = "clob", feature = "gamma", feature = "data"))]
impl PolymarketBuilder {
    fn new(account: Account) -> Self {
        Self {
            clob_base_url: None,
            gamma_base_url: None,
            data_base_url: None,
            timeout_ms: None,
            chain: None,
            account,
        }
    }

    /// Set CLOB base URL
    pub fn clob_base_url(mut self, url: impl Into<String>) -> Self {
        self.clob_base_url = Some(url.into());
        self
    }

    /// Set Gamma base URL
    pub fn gamma_base_url(mut self, url: impl Into<String>) -> Self {
        self.gamma_base_url = Some(url.into());
        self
    }

    /// Set Data API base URL
    pub fn data_base_url(mut self, url: impl Into<String>) -> Self {
        self.data_base_url = Some(url.into());
        self
    }

    /// Set request timeout in milliseconds
    pub fn timeout_ms(mut self, timeout: u64) -> Self {
        self.timeout_ms = Some(timeout);
        self
    }

    /// Set chain
    pub fn chain(mut self, chain: Chain) -> Self {
        self.chain = Some(chain);
        self
    }

    /// Build the Polymarket client
    pub fn build(self) -> Result<Polymarket, PolymarketError> {
        // Build Gamma client
        let mut gamma_builder = Gamma::builder();

        if let Some(url) = self.gamma_base_url {
            gamma_builder = gamma_builder.base_url(url);
        }
        if let Some(timeout) = self.timeout_ms {
            gamma_builder = gamma_builder.timeout_ms(timeout);
        }

        let gamma = gamma_builder.build()?;

        // Build CLOB client
        let mut clob_builder = ClobBuilder::new().with_account(self.account);

        if let Some(url) = self.clob_base_url {
            clob_builder = clob_builder.base_url(url);
        }
        if let Some(timeout) = self.timeout_ms {
            clob_builder = clob_builder.timeout_ms(timeout);
        }
        if let Some(chain) = self.chain {
            clob_builder = clob_builder.chain(chain);
        }

        let clob = clob_builder.build()?;

        // Build Data API client
        let mut data_builder = DataApiBuilder::default();

        if let Some(url) = self.data_base_url {
            data_builder = data_builder.base_url(url);
        }
        if let Some(timeout) = self.timeout_ms {
            data_builder = data_builder.timeout_ms(timeout);
        }

        let data = data_builder.build()?;

        Ok(Polymarket { clob, gamma, data })
    }
}
```

--------------------------------

### Get Chain ID

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/enum.Chain.html

Retrieves the unique chain ID for a given Chain variant. This is useful for network identification.

```rust
pub const fn chain_id(&self) -> u64
```

--------------------------------

### Gamma Client Initialization

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Gamma.html

Provides methods for creating and configuring the Gamma client.

```APIDOC
## Gamma Client API

### Description
Methods for initializing and configuring the Gamma API client.

### Methods

#### `new()`
- **Description**: Creates a new Gamma client with default configuration.
- **Returns**: `Result<Gamma, GammaError>`

#### `builder()`
- **Description**: Creates a builder for configuring the Gamma client.
- **Returns**: `GammaBuilder`
```

--------------------------------

### Get Owned Type

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/struct.Polymarket.html

Associated type `Owned` representing the type obtained after taking ownership, typically `Self` when `T` implements `Clone`.

```rust
type Owned = T
```

--------------------------------

### Creating Account with Private Key and Credentials

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Account.html

Creates a new Account instance using a provided private key and API credentials. The private key should be hex-encoded.

```rust
use polyoxide_clob::{Account, Credentials};

let credentials = Credentials {
    key: "api_key".to_string(),
    secret: "api_secret".to_string(),
    passphrase: "passphrase".to_string(),
};

let account = Account::new("0x...", credentials)?;
```

--------------------------------

### DataApi Client Initialization

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.DataApi.html

Methods for creating and configuring the DataApi client.

```APIDOC
## DataApi Initialization

### Description
Methods to instantiate or configure the DataApi client.

### Methods
- **new() -> Result<DataApi, DataApiError>** - Creates a new Data API client with default configuration.
- **builder() -> DataApiBuilder** - Creates a builder for configuring the client.
```

--------------------------------

### Loading Account from Environment Variables

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Account.html

Loads account credentials and private key from environment variables. Ensure POLYMARKET_PRIVATE_KEY, POLYMARKET_API_KEY, POLYMARKET_API_SECRET, and POLYMARKET_API_PASSPHRASE are set.

```rust
use polyoxide_clob::Account;

// Load from environment variables
let account = Account::from_env()?;
```

--------------------------------

### Loading Account from JSON File

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Account.html

Loads account credentials and private key from a JSON configuration file. The file must contain 'private_key', 'key', 'secret', and 'passphrase' fields.

```rust
use polyoxide_clob::Account;

// Or load from a JSON file
let account = Account::from_file("config/account.json")?;
```

--------------------------------

### Account Creation and Loading

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Account.html

Methods for creating and loading Account instances from different sources.

```APIDOC
## impl Account

### pub fn new( private_key: impl Into<String>, credentials: Credentials, ) -> Result<Account, ClobError>

#### Description
Create a new account from private key and credentials.

#### Arguments
* `private_key` (String) - Hex-encoded private key (with or without 0x prefix)
* `credentials` (Credentials) - API credentials for L2 authentication

#### Example
```rust
use polyoxide_clob::{Account, Credentials};

let credentials = Credentials {
    key: "api_key".to_string(),
    secret: "api_secret".to_string(),
    passphrase: "passphrase".to_string(),
};

let account = Account::new("0x...", credentials)?;
```

### pub fn from_env() -> Result<Account, ClobError>

#### Description
Load account from environment variables.
Reads the following environment variables:
  * `POLYMARKET_PRIVATE_KEY`: Hex-encoded private key
  * `POLYMARKET_API_KEY`: API key
  * `POLYMARKET_API_SECRET`: API secret (base64 encoded)
  * `POLYMARKET_API_PASSPHRASE`: API passphrase

#### Example
```rust
use polyoxide_clob::Account;

let account = Account::from_env()?;
```

### pub fn from_file(path: impl AsRef<Path>) -> Result<Account, ClobError>

#### Description
Load account from a JSON configuration file.
The file should contain:
```json
{
    "private_key": "0x...",
    "key": "api_key",
    "secret": "api_secret",
    "passphrase": "passphrase"
}
```

#### Example
```rust
use polyoxide_clob::Account;

let account = Account::from_file("config/account.json")?;
```

### pub fn from_json(json: &str) -> Result<Account, ClobError>

#### Description
Load account from a JSON string.

#### Example
```rust
use polyoxide_clob::Account;

let json = r#"{ 
    "private_key": "0x...",
    "key": "api_key",
    "secret": "api_secret",
    "passphrase": "passphrase"
}"#;

let account = Account::from_json(json)?;
```
```

--------------------------------

### Create New Polymarket Client

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/struct.Polymarket.html

Initializes a new Polymarket client instance using an Account. This method returns a Result, indicating potential errors during client creation.

```rust
pub fn new(account: Account) -> Result<Self, PolymarketError>
```

--------------------------------

### Polyoxide Prelude

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/index.html

The prelude module provides convenient re-exports for commonly used items from the polyoxide crate, simplifying imports.

```APIDOC
## Module prelude
polyoxide
# Module prelude Copy item path
Source
Search
Settings
Help
Summary
Expand description
Prelude module for convenient imports
## Re-exports§
`pub use crate::Polymarket;`
`pub use crate::PolymarketBuilder;`
`pub use crate::PolymarketError;`
```

--------------------------------

### Combine Policies with AND

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.CreateOrderParams.html

Creates a new `Policy` that returns `Action::Follow` only if both `self` and `other` policies return `Action::Follow`.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
```

--------------------------------

### Clob Initialization

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Clob.html

Methods for creating instances of the Clob client, including authenticated and read-only access.

```APIDOC
## Clob Initialization

### `new`

```rust
pub fn new(private_key: impl Into<String>, credentials: Credentials) -> Result<Clob, ClobError>
```

**Description**: Creates a new CLOB client with default configuration using a private key and credentials.

### `public`

```rust
pub fn public() -> Clob
```

**Description**: Creates a new public CLOB client for read-only access.

### `builder`

```rust
pub fn builder(private_key: impl Into<String>, credentials: Credentials) -> Result<ClobBuilder, ClobError>
```

**Description**: Creates a new CLOB client builder with required authentication.

### `from_account`

```rust
pub fn from_account(account: Account) -> Result<Clob, ClobError>
```

**Description**: Creates a new CLOB client from an existing `Account` object.
```

--------------------------------

### Combine Policies with OR

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.CreateOrderParams.html

Creates a new `Policy` that returns `Action::Follow` if either `self` or `other` policies return `Action::Follow`.

```rust
fn or<P, B, E>(self, other: P) -> Or<T, P>
```

--------------------------------

### Polymarket Client Creation

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/struct.Polymarket.html

Methods for creating a new Polymarket client instance.

```APIDOC
## Implementations

### impl Polymarket

#### pub fn new(account: Account) -> Result<Self, PolymarketError>
Create a new client from an Account

#### pub fn builder(account: Account) -> PolymarketBuilder
Create a new builder with an Account
```

--------------------------------

### Create Polymarket Client Builder

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/struct.Polymarket.html

Returns a builder for constructing a Polymarket client with an Account. This allows for more complex or configurable client initialization.

```rust
pub fn builder(account: Account) -> PolymarketBuilder
```

--------------------------------

### Loading Account from JSON String

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Account.html

Loads account credentials and private key directly from a JSON formatted string. Ensure the JSON contains 'private_key', 'key', 'secret', and 'passphrase'.

```rust
use polyoxide_clob::Account;

let json = r#"{{
    "private_key": "0x...",
    "key": "api_key",
    "secret": "api_secret",
    "passphrase": "passphrase"
}}"#;

let account = Account::from_json(json)?;
```

--------------------------------

### PolymarketBuilder Configuration Methods

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/struct.PolymarketBuilder.html

Methods available on the PolymarketBuilder to configure the client environment and connection settings.

```APIDOC
## PolymarketBuilder Configuration

### Description
Methods to configure the Polymarket client before instantiation.

### Methods
- **clob_base_url(url: impl Into<String>) -> Self**: Set CLOB base URL.
- **gamma_base_url(url: impl Into<String>) -> Self**: Set Gamma base URL.
- **data_base_url(url: impl Into<String>) -> Self**: Set Data API base URL.
- **timeout_ms(timeout: u64) -> Self**: Set request timeout in milliseconds.
- **chain(chain: Chain) -> Self**: Set the target chain.
- **build() -> Result<Polymarket, PolymarketError>**: Finalize configuration and build the Polymarket client.
```

--------------------------------

### Any Trait

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Account.html

Provides runtime type information.

```APIDOC
## Any Trait

### Description
Provides runtime type information for trait objects.

### Methods
#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.
```

--------------------------------

### Combine Policies with OR

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/struct.Polymarket.html

Creates a new `Policy` that succeeds if either `self` or `other` policy returns `Action::Follow`. Useful for alternative conditions.

```rust
fn or<P, B, E>(self, other: P) -> Or<T, P>
where T: Policy<B, E>, P: Policy<B, E>,
```

--------------------------------

### Combine Policies with AND

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/struct.Polymarket.html

Creates a new `Policy` that requires both `self` and `other` policies to return `Action::Follow` to succeed. Useful for sequential or combined conditions.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
where T: Policy<B, E>, P: Policy<B, E>,
```

--------------------------------

### CloneToUninit Trait

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Account.html

Nightly-only experimental API for cloning to uninitialized memory.

```APIDOC
## CloneToUninit Trait

### Description
🔬 This is a nightly-only experimental API. Performs copy-assignment from `self` to `dest`.

### Methods
#### unsafe fn clone_to_uninit(&self, dest: *mut u8)
Performs copy-assignment from `self` to `dest`.
```

--------------------------------

### Same

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Clob.html

Defines an associated type `Output` which should always be `Self`.

```APIDOC
## type Output = T

### Description
This associated type should always be `Self`.

### Method
N/A (Associated type)

### Endpoint
N/A (Trait definition)

### Parameters
None

### Request Body
None

### Response
N/A

### Response Example
N/A
```

--------------------------------

### Execute VZip Operation

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.CreateOrderParams.html

Performs the zipping operation on the current instance.

```rust
fn vzip(self) -> V
```

--------------------------------

### VZip Implementation

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.CreateOrderParams.html

Implementation of VZip for types that support MultiLane.

```APIDOC
## impl<V, T> VZip<V> for T

### Description
Implementation of VZip for types that support MultiLane.

### Source
```rust
where V: MultiLane<T>,
```

#### fn vzip

### Description
Returns a VZip wrapper.

### Source
```rust
fn vzip(self) -> V;
```
```

--------------------------------

### WithSubscriber Implementation

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.CreateOrderParams.html

Implementation of WithSubscriber for attaching subscribers.

```APIDOC
## impl<T> WithSubscriber for T

### Description
Implementation of WithSubscriber for attaching subscribers.

### Source
```rust
impl<T> WithSubscriber for T
```

#### fn with_subscriber

### Description
Attaches the provided `Subscriber` to this type, returning a `WithDispatch` wrapper.

### Parameters
#### Request Body
- **subscriber** (S) - Required - The subscriber to attach.

### Source
```rust
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>;
```
```

```APIDOC
#### fn with_current_subscriber

### Description
Attaches the current default `Subscriber` to this type, returning a `WithDispatch` wrapper.

### Source
```rust
fn with_current_subscriber(self) -> WithDispatch<Self>;
```
```

--------------------------------

### ClobBuilder Configuration Methods

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.ClobBuilder.html

Methods available on the ClobBuilder to configure the CLOB client instance.

```APIDOC
## ClobBuilder Configuration

### Description
Methods to configure the CLOB client before building it.

### Methods
- **new()** -> ClobBuilder: Create a new builder with default configuration.
- **with_account(account: Account)** -> ClobBuilder: Set account for the client.
- **base_url(url: impl Into<String>)** -> ClobBuilder: Set base URL for the API.
- **timeout_ms(timeout: u64)** -> ClobBuilder: Set request timeout in milliseconds.
- **pool_size(size: usize)** -> ClobBuilder: Set connection pool size.
- **chain(chain: Chain)** -> ClobBuilder: Set chain.
- **gamma(gamma: Gamma)** -> ClobBuilder: Set Gamma client.
- **with_retry_config(config: RetryConfig)** -> ClobBuilder: Set retry configuration for 429 responses.
- **max_concurrent(max: usize)** -> ClobBuilder: Set the maximum number of concurrent in-flight requests (Default: 8).
- **build()** -> Result<Clob, ClobError>: Build the CLOB client.
```

--------------------------------

### PolymarketBuilder API

Source: https://docs.rs/polyoxide/0.12.1/src/polyoxide/lib.rs.html

This section details the methods available on the PolymarketBuilder for configuring various aspects of the Polymarket client before building it.

```APIDOC
## PolymarketBuilder

### Description
Builder for the Polymarket client. Allows configuration of base URLs for different services, request timeout, and the blockchain chain.

### Methods

#### `new(account: Account) -> Self`

- **Description**: Creates a new instance of `PolymarketBuilder` with the provided `Account`.
- **Parameters**:
  - `account` (Account) - The account to be used for the Polymarket client.

#### `clob_base_url(url: impl Into<String>) -> Self`

- **Description**: Sets the base URL for the CLOB (Central Limit Order Book) service.
- **Parameters**:
  - `url` (impl Into<String>) - The base URL for the CLOB service.

#### `gamma_base_url(url: impl Into<String>) -> Self`

- **Description**: Sets the base URL for the Gamma service.
- **Parameters**:
  - `url` (impl Into<String>) - The base URL for the Gamma service.

#### `data_base_url(url: impl Into<String>) -> Self`

- **Description**: Sets the base URL for the Data API service.
- **Parameters**:
  - `url` (impl Into<String>) - The base URL for the Data API service.

#### `timeout_ms(timeout: u64) -> Self`

- **Description**: Sets the request timeout in milliseconds for all services.
- **Parameters**:
  - `timeout` (u64) - The timeout duration in milliseconds.

#### `chain(chain: Chain) -> Self`

- **Description**: Sets the blockchain chain to be used.
- **Parameters**:
  - `chain` (Chain) - The `Chain` enum value representing the desired blockchain.

#### `build(self) -> Result<Polymarket, PolymarketError>`

- **Description**: Builds and returns a `Polymarket` client instance with the configured settings. Returns a `Result` which is `Ok(Polymarket)` on success or `Err(PolymarketError)` on failure.
- **Returns**:
  - `Result<Polymarket, PolymarketError>` - The constructed `Polymarket` client or an error.

### Example Usage

```rust
use polymarket::PolymarketBuilder;
use polymarket::Account;
use polymarket::Chain;

// Assuming you have an Account instance and a Chain enum value
let account: Account = Account::new("your_private_key"); // Example account creation
let chain: Chain = Chain::Mainnet; // Example chain

let polymarket_client = PolymarketBuilder::new(account)
    .clob_base_url("https://clob.example.com")
    .gamma_base_url("https://gamma.example.com")
    .data_base_url("https://data.example.com")
    .timeout_ms(5000)
    .chain(chain)
    .build();

match polymarket_client {
    Ok(client) => {
        // Use the client
        println!("Polymarket client built successfully!");
    }
    Err(e) => {
        eprintln!("Failed to build Polymarket client: {}", e);
    }
}
```
```

--------------------------------

### Validate Order Parameters

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.CreateOrderParams.html

Validates that price and size are finite and within expected ranges before creating an order.

```rust
pub fn validate(&self) -> Result<(), ClobError>
```

--------------------------------

### CreateOrderParams Struct

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.CreateOrderParams.html

Defines the parameters required for creating an order.

```APIDOC
## Struct CreateOrderParams

### Description
Parameters for creating an order.

### Fields
- **token_id** (String) - The ID of the token.
- **price** (f64) - The price of the order.
- **size** (f64) - The size of the order.
- **side** (OrderSide) - The side of the order (e.g., buy or sell).
- **order_type** (OrderKind) - The type of the order (e.g., limit, market).
- **post_only** (bool) - Whether the order should be post-only.
- **expiration** (Option<u64>) - The expiration time of the order in seconds.
- **funder** (Option<Address>) - The address funding the order.
- **signature_type** (Option<SignatureType>) - The type of signature used for the order.

### Methods
#### `validate(&self) -> Result<(), ClobError>`
Validate price and size are finite and within expected ranges.
```

--------------------------------

### TryFrom<U>

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Clob.html

Provides a method for fallible conversion from one type to another.

```APIDOC
## type Error = Infallible

### Description
The type returned in the event of a conversion error. This is `Infallible` for this specific implementation, meaning conversion is always successful.

### Method
N/A (Associated type)

### Endpoint
N/A (Trait definition)

### Parameters
None

### Request Body
None

### Response
N/A

### Response Example
N/A
```

```APIDOC
## try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion from type `U` to type `T`.

### Method
`try_from`

### Endpoint
N/A (Trait method)

### Parameters
- **value** (U) - Required - The value to convert.

### Request Body
None

### Response
Returns a `Result<T, Error>` where `T` is the target type and `Error` is the conversion error type.

### Response Example
N/A (Trait method)
```

--------------------------------

### From and Into Traits

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Account.html

Facilitates type conversions.

```APIDOC
## From and Into Traits

### Description
Enables conversions between types.

### Methods
#### fn from(t: T) -> T
Returns the argument unchanged.

#### fn into(self) -> U
Calls `U::from(self)`.
```

--------------------------------

### TryInto<U>

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Clob.html

Provides a method for fallible conversion into another type.

```APIDOC
## type Error = <U as TryFrom<T>>::Error

### Description
The type returned in the event of a conversion error.

### Method
N/A (Associated type)

### Endpoint
N/A (Trait definition)

### Parameters
None

### Request Body
None

### Response
N/A

### Response Example
N/A
```

```APIDOC
## try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion from `self` (type `T`) into type `U`.

### Method
`try_into`

### Endpoint
N/A (Trait method)

### Parameters
None

### Request Body
None

### Response
Returns a `Result<U, Error>` where `U` is the target type and `Error` is the conversion error type.

### Response Example
N/A (Trait method)
```

--------------------------------

### Order Management API

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Clob.html

Methods for creating, signing, and posting orders to the CLOB.

```APIDOC
## Order Management API

### `create_order`

```rust
pub async fn create_order(&self, params: &CreateOrderParams, options: Option<PartialCreateOrderOptions>) -> Result<Order, ClobError>
```

**Description**: Creates an unsigned order from the provided parameters and optional options.

### `create_market_order`

```rust
pub async fn create_market_order(&self, params: &MarketOrderArgs, options: Option<PartialCreateOrderOptions>) -> Result<Order, ClobError>
```

**Description**: Creates an unsigned market order from the provided arguments and optional options.

### `sign_order`

```rust
pub async fn sign_order(&self, order: &Order) -> Result<SignedOrder, ClobError>
```

**Description**: Signs an order using the configured account's EIP-712 signer.

### `post_orders`

```rust
pub async fn post_orders(&self, orders: &[SignedOrderPayload]) -> Result<Vec<OrderResponse>, ClobError>
```

**Description**: Posts multiple signed orders (up to 15) to the CLOB.

### `post_order`

```rust
pub async fn post_order(&self, signed_order: &SignedOrder, order_type: OrderKind, post_only: bool) -> Result<OrderResponse, ClobError>
```

**Description**: Posts a single signed order to the CLOB.

### `place_order`

```rust
pub async fn place_order(&self, params: &CreateOrderParams, options: Option<PartialCreateOrderOptions>) -> Result<OrderResponse, ClobError>
```

**Description**: A convenience method to create, sign, and post an order.

### `place_market_order`

```rust
pub async fn place_market_order(&self, params: &MarketOrderArgs, options: Option<PartialCreateOrderOptions>) -> Result<OrderResponse, ClobError>
```

**Description**: A convenience method to create, sign, and post a market order.
```

--------------------------------

### Try Into Conversion

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.CreateOrderParams.html

Provides a method to attempt conversion between types, returning a Result.

```APIDOC
## fn try_into

### Description
Performs the conversion.

### Source
```rust
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>;
```
```

--------------------------------

### Policy Composition

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/enum.OrderKind.html

Documentation for the 'or' method used to combine policies.

```APIDOC
## fn or<P, B, E>(self, other: P) -> Or<T, P>

### Description
Creates a new `Policy` that returns `Action::Follow` if either `self` or `other` returns `Action::Follow`.

### Parameters
#### Request Body
- **other** (P) - Required - The other policy to combine with the current policy.
```

--------------------------------

### Or Policy Trait

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/enum.ClobError.html

Implements a new Policy that combines two existing policies, returning Action::Follow if either policy returns Action::Follow.

```APIDOC
## Or<P, B, E> for Policy

### Description
Creates a new `Policy` that returns `Action::Follow` if either `self` or `other` returns `Action::Follow`.

### Method
`fn or<P, B, E>(self, other: P) -> Or<T, P>`

### Parameters
- **other** (P) - The other policy to combine with.

### Response
- **Or<T, P>** - A new policy combining `self` and `other`.
```

--------------------------------

### PolicyExt

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Clob.html

Provides methods for combining policies.

```APIDOC
## and<P, B, E>(other: P)

### Description
Creates a new `Policy` that returns `Action::Follow` only if `self` and `other` both return `Action::Follow`.

### Method
`and`

### Endpoint
N/A (Trait method)

### Parameters
- **other** (P) - Required - The other policy to combine with.

### Request Body
None

### Response
Returns a new `And<T, P>` policy.

### Response Example
N/A (Trait method)
```

```APIDOC
## or<P, B, E>(other: P)

### Description
Creates a new `Policy` that returns `Action::Follow` if either `self` or `other` returns `Action::Follow`.

### Method
`or`

### Endpoint
N/A (Trait method)

### Parameters
- **other** (P) - Required - The other policy to combine with.

### Request Body
None

### Response
Returns a new `Or<T, P>` policy.

### Response Example
N/A (Trait method)
```

--------------------------------

### Signing an Order with EIP-712

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Account.html

Signs an unsigned order using the EIP-712 standard. Requires the order object and the chain ID for domain separation.

```rust
use polyoxide_clob::{Account, Order};

async fn example(account: &Account, order: &Order) -> Result<(), Box<dyn std::error::Error>> {
    let signed_order = account.sign_order(order, 137).await?;
    println!("Signature: {}", signed_order.signature);
    Ok(())
}
```

--------------------------------

### Debug Implementation for CreateOrderParams

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.CreateOrderParams.html

Provides a debug formatting implementation for CreateOrderParams.

```APIDOC
### impl Debug for CreateOrderParams

#### `fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>`
Formats the value using the given formatter.
```

--------------------------------

### Clone to Uninitialized Memory (Nightly)

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.CreateOrderParams.html

Performs copy-assignment from `self` to uninitialized memory at `dest`. This is a nightly-only experimental API.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```

--------------------------------

### PolicyExt Implementation

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/enum.Chain.html

Extends types with policy composition methods like 'and' and 'or'. These methods combine two policies into a new one.

```rust
fn and<P, B, E>(self, other: P) -> And<T, P>
```

```rust
fn or<P, B, E>(self, other: P) -> Or<T, P>
```

--------------------------------

### Polyoxide Structs

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/index.html

This section lists and describes the core structs available in the polyoxide crate, detailing their purpose and functionality.

```APIDOC
## Structs§

Account
    Unified account primitive for credential management and signing operations.

Clob
    CLOB (Central Limit Order Book) trading client for Polymarket.

ClobBuilder
    Builder for CLOB client

CreateOrderParams
    Parameters for creating an order

Credentials
    API credentials for L2 authentication

DataApi
    Main Data API client

Gamma
    Main Gamma API client
```

--------------------------------

### Policy Trait - Or Operation

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/enum.OrderSide.html

Implements a new Policy that combines two existing policies. It returns Action::Follow if either of the policies returns Action::Follow.

```APIDOC
## fn or<P, B, E>(self, other: P) -> Or<T, P>

### Description
Create a new `Policy` that returns `Action::Follow` if either `self` or `other` returns `Action::Follow`.

### Method
`or`

### Endpoint
N/A (Trait method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
None

### Request Example
None

### Response
#### Success Response (200)
`Or<T, P>`: A new Policy type.

#### Response Example
None
```

--------------------------------

### Same Trait

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/enum.SignatureType.html

Indicates that the output type is the same as the self type.

```APIDOC
## Same Trait

### Description
Indicates that the output type is the same as the self type.

### Associated Types

#### `type Output = T`

Should always be `Self`.
```

--------------------------------

### Polymarket Trait Implementations

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/struct.Polymarket.html

Details on the traits implemented by the Polymarket struct, such as Clone and various auto traits.

```APIDOC
## Trait Implementations

### impl Clone for Polymarket
#### fn clone(&self) -> Polymarket
Returns a duplicate of the value.

#### fn clone_from(&mut self, source: &Self)
Performs copy-assignment from `source`.

### Auto Trait Implementations
- Freeze
- !RefUnwindSafe
- Send
- Sync
- Unpin
- UnsafeUnpin
- !UnwindSafe
```

--------------------------------

### Gamma Trait Implementations

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Gamma.html

Details on the traits implemented by the Gamma struct.

```APIDOC
## Gamma Trait Implementations

### Description
This section outlines the standard Rust traits implemented by the `Gamma` struct, providing common functionalities.

### Implemented Traits

- **`Clone`**: Allows creating duplicate instances of `Gamma`.
  - `clone()`: Returns a duplicate of the value.
  - `clone_from()`: Performs copy-assignment from a source.

- **`Send`**: Indicates that `Gamma` can be safely transferred between threads.

- **`Sync`**: Indicates that `Gamma` can be safely shared between threads.

- **`Any`**: Provides runtime type information.
  - `type_id()`: Gets the `TypeId` of `self`.

- **`Borrow<T>`**: Allows borrowing `Gamma` as a reference of type `T`.
  - `borrow()`: Immutably borrows from an owned value.

- **`BorrowMut<T>`**: Allows mutable borrowing of `Gamma` as a reference of type `T`.
  - `borrow_mut()`: Mutably borrows from an owned value.

- **`From<T>`**: Enables conversion from type `T` into `Gamma`.
  - `from(t: T)`: Returns the argument unchanged.

- **`Instrument`**: Allows instrumenting `Gamma` with spans for tracing.
  - `instrument()`: Instruments with a provided `Span`.
  - `in_current_span()`: Instruments with the current `Span`.

- **`Into<U>`**: Enables conversion from `Gamma` into type `U` if `U` implements `From<Gamma>`.
  - `into()`: Calls `U::from(self)`.

- **`IntoEither`**: Provides methods to convert `Gamma` into an `Either` variant.
  - `into_either()`: Converts into `Left` or `Right` based on a boolean.
  - `into_either_with()`: Converts based on a closure's boolean result.

- **`PolicyExt`**: Extends `Gamma` with policy combinators.
  - `and()`: Creates a new policy that requires both policies to succeed.
  - `or()`: Creates a new policy that succeeds if either policy succeeds.

- **`Same`**: Indicates that the output type is the same as the input type.
  - `Output`: Associated type, always `Self`.

- **`ToOwned`**: Allows creating an owned version of `Gamma`.
  - `Owned`: Associated type, which is `Gamma`.
  - `to_owned()`: Creates owned data, usually by cloning.
  - `clone_into()`: Uses borrowed data to replace owned data.

- **`TryFrom<U>`**: Enables fallible conversion from type `U` into `Gamma`.
  - `Error`: Associated type, `Infallible`.
  - `try_from()`: Performs the conversion.

- **`TryInto<U>`**: Enables fallible conversion from `Gamma` into type `U`.
  - `Error`: Associated type, the error type of `U`'s `TryFrom` implementation.
  - `try_into()`: Performs the conversion.
```

--------------------------------

### Polymarket Blanket Implementations

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/struct.Polymarket.html

Details on blanket implementations provided for the Polymarket struct through generic traits.

```APIDOC
## Blanket Implementations

### impl<T> Any for T
#### fn type_id(&self) -> TypeId
Gets the `TypeId` of `self`.

### impl<T> Borrow<T> for T
#### fn borrow(&self) -> &T
Immutably borrows from an owned value.

### impl<T> BorrowMut<T> for T
#### fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value.

### impl<T> CloneToUninit for T
#### unsafe fn clone_to_uninit(&self, dest: *mut u8)
Performs copy-assignment from `self` to `dest`.

### impl<T> From<T> for T
#### fn from(t: T) -> T
Returns the argument unchanged.

### impl<T> Instrument for T
#### fn instrument(self, span: Span) -> Instrumented<Self>
Instruments this type with the provided `Span`.
#### fn in_current_span(self) -> Instrumented<Self>
Instruments this type with the current `Span`.

### impl<T, U> Into<U> for T
#### fn into(self) -> U
Calls `U::from(self)`.

### impl<T> IntoEither for T
#### fn into_either(self, into_left: bool) -> Either<Self, Self>
Converts `self` into a `Left` or `Right` variant of `Either`.
#### fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
Converts `self` into a `Left` or `Right` variant of `Either` based on a predicate.

### impl<T> PolicyExt for T
#### fn and<P, B, E>(self, other: P) -> And<T, P>
Creates a new `Policy` that returns `Action::Follow` only if `self` and `other` return `Action::Follow`.
#### fn or<P, B, E>(self, other: P) -> Or<T, P>
Creates a new `Policy` that returns `Action::Follow` if either `self` or `other` returns `Action::Follow`.

### impl<T> Same for T
#### type Output = T
Should always be `Self`.

### impl<T> ToOwned for T
#### type Owned = T
The resulting type after obtaining ownership.
#### fn to_owned(&self) -> T
Creates owned data from borrowed data, usually by cloning.
#### fn clone_into(&self, target: &mut T)
Uses borrowed data to replace owned data, usually by cloning.

### impl<T, U> TryFrom<U> for T
#### type Error = Infallible
The type returned in the event of a conversion error.
#### fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
Performs the conversion.

### impl<T, U> TryInto<U> for T
#### type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
#### fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
Performs the conversion.

### impl<V, T> VZip<V> for T
#### fn vzip(self) -> V

### impl<T> WithSubscriber for T
```

--------------------------------

### Account Struct Overview

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Account.html

The Account struct provides a unified interface for managing credentials and performing signing operations. It combines wallet information, API credentials, and signing functionalities.

```APIDOC
## Struct Account

### Description
Unified account primitive for credential management and signing operations.
`Account` combines wallet (private key), API credentials, and signing capabilities into a single abstraction. It provides factory methods for loading credentials from various sources (environment variables, files) and handles both EIP-712 order signing and HMAC-based L2 API authentication.

### Example
```rust
use polyoxide_clob::Account;

// Load from environment variables
let account = Account::from_env()?;

// Or load from a JSON file
let account = Account::from_file("config/account.json")?;

// Get the wallet address
println!("Address: {:?}", account.address());
```
```

--------------------------------

### Define Credentials Struct

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Credentials.html

The structure used for storing L2 authentication credentials.

```rust
pub struct Credentials {
    pub key: String,
    pub secret: String,
    pub passphrase: String,
}
```

--------------------------------

### Clone Polymarket Instance

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/struct.Polymarket.html

Provides a method to create a duplicate of an existing Polymarket instance. This is useful for scenarios requiring independent client instances.

```rust
fn clone(&self) -> Polymarket
```

--------------------------------

### Gamma Struct Definition

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Gamma.html

The internal structure definition for the Gamma client.

```rust
pub struct Gamma { /* private fields */ }
```

--------------------------------

### Credentials Struct

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Credentials.html

Represents API credentials for L2 authentication, including key, secret, and passphrase.

```APIDOC
## Struct Credentials

### Description
API credentials for L2 authentication.

### Fields
- **key** (String) - The API key.
- **secret** (String) - The API secret.
- **passphrase** (String) - The API passphrase.

### Trait Implementations
- **Clone**: Allows creating a duplicate of the Credentials.
- **Debug**: Enables formatting for debugging purposes.
- **Deserialize**: Allows deserializing Credentials from a Serde deserializer.
- **Serialize**: Allows serializing Credentials to a Serde serializer.

### Auto Trait Implementations
- Freeze
- RefUnwindSafe
- Send
- Sync
- Unpin
- UnsafeUnpin
- UnwindSafe

### Blanket Implementations
- Any
- Borrow
- BorrowMut
- CloneToUninit (Nightly-only)
- From
- Instrument
- Into
- IntoEither
- PolicyExt
- Same
- ToOwned
- TryFrom
- TryInto
```

--------------------------------

### Into<U>

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Clob.html

Provides a method to convert a type into another type using the `From` trait.

```APIDOC
## into()

### Description
Calls `U::from(self)`. This conversion is determined by the implementation of `From<T> for U`.

### Method
`into`

### Endpoint
N/A (Trait method)

### Parameters
None

### Request Body
None

### Response
Returns an instance of type `U`.

### Response Example
N/A (Trait method)
```

--------------------------------

### Conversion Traits (TryFrom/TryInto)

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/enum.PolymarketError.html

Standard conversion traits for fallible type transformations.

```APIDOC
## TryFrom<U>

### Description
Trait for performing fallible conversions from type U to T.

### Associated Types
- **Error** (Infallible) - The type returned in the event of a conversion error.

### Methods
- **try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>** - Performs the conversion.

## TryInto<U>

### Description
Trait for performing fallible conversions into type U.

### Associated Types
- **Error** (<U as TryFrom<T>>::Error) - The type returned in the event of a conversion error.

### Methods
- **try_into(self) -> Result<U, <U as TryFrom<T>>::Error>** - Performs the conversion.
```

--------------------------------

### CreateOrderParams Struct Definition

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.CreateOrderParams.html

Defines the structure for creating an order with various parameters.

```rust
pub struct CreateOrderParams {
    pub token_id: String,
    pub price: f64,
    pub size: f64,
    pub side: OrderSide,
    pub order_type: OrderKind,
    pub post_only: bool,
    pub expiration: Option<u64>,
    pub funder: Option<Address>,
    pub signature_type: Option<SignatureType>,
}
```

--------------------------------

### Same Trait

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Account.html

Represents a type that is the same as itself.

```APIDOC
## Same Trait

### Description
Represents a type that is the same as itself.

### Associated Types
#### type Output = T
Should always be `Self`.
```

--------------------------------

### Equivalent Implementation

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/enum.Chain.html

Checks if a value is equivalent to a given key. This is used for comparisons where types might differ but represent the same value.

```rust
fn equivalent(&self, key: &K) -> bool
```

--------------------------------

### PolymarketBuilder Struct Definition

Source: https://docs.rs/polyoxide/0.12.1/src/polyoxide/lib.rs.html

Defines the builder structure requiring clob, gamma, and data features.

```rust
#[cfg(all(feature = "clob", feature = "gamma", feature = "data"))]
pub struct PolymarketBuilder {
    clob_base_url: Option<String>,
    gamma_base_url: Option<String>,
    data_base_url: Option<String>,
    timeout_ms: Option<u64>,
    chain: Option<Chain>,
    account: Account,
}
```

--------------------------------

### TryFrom Trait

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/enum.ClobError.html

Enables fallible conversion from one type to another.

```APIDOC
## TryFrom<U> for T

### Description
Performs the conversion from type `U` to type `T`.

### Method
`fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>`

### Parameters
- **value** (U) - The value to convert.

### Response
- **Result<T, <T as TryFrom<U>>::Error>** - A `Result` containing the converted value or an error.
```

--------------------------------

### Conversion and RPC Traits

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.Credentials.html

General purpose traits for type conversion and RPC object handling.

```APIDOC
## fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

### Description
Performs the conversion from the current type to the target type U.

## fn vzip(self) -> V

### Description
Performs a multi-lane zip operation on the type.
```

--------------------------------

### Polyoxide Enums

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/index.html

This section outlines the enumerations provided by the polyoxide crate, including types for chains, order details, and API errors.

```APIDOC
## Enums§

Chain


ClobError
    Error types for CLOB API operations

DataApiError
    Error types for Data API operations

GammaError
    Error types for gamma API operations

OrderKind
    Order type/kind

OrderSide
    Side of an order (buy or sell).

SignatureType
    Signature type for order signing (EOA, Proxy, or Gnosis Safe).
```

--------------------------------

### Attach Subscriber to Type

Source: https://docs.rs/polyoxide/0.12.1/polyoxide/prelude/struct.CreateOrderParams.html

Wraps the current type with a subscriber to enable dispatching.

```rust
fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,
```
Tokens:
Raw