Struct AuthenticatedClient 

pub struct AuthenticatedClient { /* private fields */ }

Client for authenticated operations

This client handles operations that require authentication, such as API key management and account queries.

For PolyProxy wallets, the signer is used for API authentication while the funder address is used as the order maker.

Implementations

impl AuthenticatedClient

pub fn new( host: impl Into<String>, signer: impl EthSigner + 'static, chain_id: u64, api_creds: Option<ApiCreds>, funder: Option<Address>, ) -> Self

Create a new AuthenticatedClient

Arguments

• host - The base URL for the API
• signer - The Ethereum signer (used for API authentication)
• chain_id - The chain ID (137 for Polygon, 80002 for Amoy testnet)
• api_creds - Optional API credentials for L2 operations
• funder - Optional funder address (for PolyProxy wallets, this is the proxy wallet address)

PolyProxy Wallets

For PolyProxy wallets:

• signer: Your EOA private key (delegated signer)
• funder: Your proxy wallet address (holds the funds)
• API authentication uses the signer address
• Orders are made by the funder address

pub fn api_creds(&self) -> Option<&ApiCreds>

Get the API credentials if available

Returns a reference to the API credentials if they were provided when creating the client. This is useful for accessing credentials for WebSocket authentication.

Example

let auth_client = AuthenticatedClient::new(
    "https://clob.polymarket.com",
    signer,
    137,
    Some(creds),
    None,
);

// Use the credentials for WebSocket authentication
if let Some(creds) = auth_client.api_creds() {
    let ws_client = UserWsClient::new();
    let mut stream = ws_client.subscribe_with_creds(creds).await?;
    // Process events...
}

pub fn set_api_creds(&mut self, api_creds: Option<ApiCreds>)

Set the API credentials

Updates the API credentials for this client. This is useful when you want to:

• Initialize the client without credentials
• Fetch credentials later using create_api_key() or derive_api_key()
• Update credentials without recreating the client

Example

// Create client without credentials
let mut auth_client = AuthenticatedClient::new(
    "https://clob.polymarket.com",
    signer,
    137,
    None,  // No credentials initially
    None,
);

// Fetch credentials using L1 authentication
let creds = auth_client.create_or_derive_api_key().await?;

// Set the credentials
auth_client.set_api_creds(Some(creds));

// Now you can use L2 authenticated methods
let keys = auth_client.get_api_keys().await?;

pub async fn create_api_key(&self, nonce: Option<U256>) -> Result<ApiCreds>

Create a new API key (L1 authentication required)

This creates a new API key for the signer’s address. Requires wallet signature.

pub async fn derive_api_key(&self) -> Result<ApiCreds>

Derive API key from existing credentials (L1 authentication required)

pub async fn create_or_derive_api_key(&self) -> Result<ApiCreds>

Create or derive API key with fallback

Tries to create a new API key, falls back to derive if creation fails.

pub async fn get_api_keys(&self) -> Result<ApiKeysResponse>

Get all API keys for the current user (L2 authentication required)

pub async fn delete_api_key(&self) -> Result<Value>

Delete an API key (L2 authentication required)

pub async fn get_balance_allowance( &self, params: BalanceAllowanceParams, ) -> Result<Value>

Get balance and allowance information (L2 authentication required)

Arguments

• params - Query parameters for balance/allowance

pub async fn update_balance_allowance(&self) -> Result<Value>

Update balance allowance (L2 authentication required)

pub async fn get_notifications(&self) -> Result<Value>

Get notifications for the current user (L2 authentication required)

pub async fn drop_notifications(&self, ids: &[String]) -> Result<Value>

Drop (delete) notifications (L2 authentication required)

pub fn get_address(&self) -> String

Get the signer’s address

pub fn get_funder(&self) -> Option<Address>

Get the funder address (for PolyProxy wallets)

Returns the proxy wallet address if set, otherwise None. For EOA wallets, this should return None.