Struct Config 

pub struct Config {
    pub credentials: Credentials,
    pub rest_api: RestApiConfig,
    pub websocket: WebSocketConfig,
    pub database: DatabaseConfig,
    pub rate_limiter: RateLimiterConfig,
    pub sleep_hours: u64,
    pub page_size: u32,
    pub days_to_look_back: i64,
    pub api_version: Option<u8>,
}

Main configuration for the IG Markets API client.

Debug is derived and delegates to each field’s Debug, so the redacting Credentials and DatabaseConfig impls keep secrets out of the output; Display is manual for the same reason.

Fields

credentials: Credentials

Authentication credentials

rest_api: RestApiConfig

REST API configuration

websocket: WebSocketConfig

WebSocket API configuration

database: DatabaseConfig

Database configuration for data persistence

rate_limiter: RateLimiterConfig

Rate limiter configuration for API requests

sleep_hours: u64

Number of hours between transaction fetching operations

page_size: u32

Number of items to retrieve per page in API requests

days_to_look_back: i64

Number of days to look back when fetching historical data

api_version: Option<u8>

API version to use for authentication: Some(2) for CST / X-SECURITY-TOKEN, Some(3) for OAuth. Both constructors set Some(3) (crate::constants::DEFAULT_API_VERSION); an explicit None makes login fall back to v2.

Implementations

impl Config

pub fn from_credentials(credentials: Credentials) -> Self

Creates a configuration from caller-supplied credentials, reading no environment variable and loading no .env file.

This is the injection path for embedding applications that own their configuration source (their own namespaced env vars, a config file, a secrets manager). Pair it with Client::with_config. Config::new remains the .env / IG_* convenience path.

Every non-credential field takes its documented default (IG demo endpoints — see the Default impls of RestApiConfig, WebSocketConfig, RateLimiterConfig and DatabaseConfig). Override individual sections with a struct-update expression, which stays env-free because the base value is this constructor:

use ig_client::prelude::*;

let credentials = Credentials::new(
    "user".to_string(),
    "password".to_string(),
    "ABC123".to_string(),
    "api-key".to_string(),
);
let config = Config {
    rest_api: RestApiConfig {
        base_url: "https://demo-api.ig.com/gateway/deal".to_string(),
        timeout: 30,
    },
    ..Config::from_credentials(credentials)
};
assert_eq!(config.rest_api.base_url, "https://demo-api.ig.com/gateway/deal");

Arguments

• credentials - IG credentials supplied by the caller

Returns

A Config built entirely from credentials plus the documented defaults

pub fn new() -> Self

Creates a new configuration instance from the environment.

Loads a local .env file (via dotenv) and reads the IG_* / DATABASE_* / TX_* environment variables, falling back to the documented defaults for anything unset. Embedders that must not touch the .env file or the IG_* namespace should use Config::from_credentials instead.

Returns

A new Config instance

Trait Implementations

impl Clone for Config

fn clone(&self) -> Config

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Config

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

Formats the value using the given formatter.

impl Default for Config

fn default() -> Self

Delegates to Config::new and therefore loads a .env file and reads the IG_* namespace — unlike the section-level Default impls above, which are env-free. Config { .., ..Config::default() } still touches the environment; use Config::from_credentials as the base value when that is not acceptable.

impl<'de> Deserialize<'de> for Config

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Config

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

Formats the value using the given formatter.

impl Serialize for Config

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.