Struct Account 

pub struct Account { /* private fields */ }

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

use polyte_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());

Implementations

impl Account

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

Create a new account from private key and credentials.

Arguments

• private_key - Hex-encoded private key (with or without 0x prefix)
• credentials - API credentials for L2 authentication

Example

use polyte_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<Self>

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

use polyte_clob::Account;

let account = Account::from_env()?;

pub fn from_file(path: impl AsRef<Path>) -> Result<Self>

Load account from a JSON configuration file.

The file should contain:

{
    "private_key": "0x...",
    "key": "api_key",
    "secret": "api_secret",
    "passphrase": "passphrase"
}

Example

use polyte_clob::Account;

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

pub fn from_json(json: &str) -> Result<Self>

Load account from a JSON string.

Example

use polyte_clob::Account;

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

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

pub fn address(&self) -> Address

Get the wallet address.

pub fn wallet(&self) -> &Wallet

Get a reference to the wallet.

pub fn credentials(&self) -> &Credentials

Get a reference to the credentials.

pub fn signer(&self) -> &Signer

Get a reference to the HMAC signer.

pub async fn sign_order( &self, order: &Order, chain_id: u64, ) -> Result<SignedOrder>

Sign an order using EIP-712.

Arguments

• order - The unsigned order to sign
• chain_id - The chain ID for EIP-712 domain

Example

use polyte_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(())
}

pub async fn sign_clob_auth( &self, chain_id: u64, timestamp: u64, nonce: u32, ) -> Result<String>

Sign a CLOB authentication message for API key creation (L1 auth).

Arguments

• chain_id - The chain ID for EIP-712 domain
• timestamp - Unix timestamp in seconds
• nonce - Random nonce value

pub fn sign_l2_request( &self, timestamp: u64, method: &str, path: &str, body: Option<&str>, ) -> Result<String>

Sign an L2 API request message using HMAC.

Arguments

• timestamp - Unix timestamp in seconds
• method - HTTP method (GET, POST, DELETE)
• path - Request path (e.g., “/order”)
• body - Optional request body

Trait Implementations

impl Clone for Account

fn clone(&self) -> Account

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Account

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.