feat: add SOCKS5/HTTP proxy support

Cargo.toml

@@ -23,6 +23,7 @@ serde = { version = "1", features = ["derive"] }
 tabled = "0.17"
 rust_decimal = "1"
 anyhow = "1"
+reqwest = { version = "0.13", features = ["socks"] }
 chrono = "0.4"
 dirs = "6"
 rustyline = "15"

src/config.rs

@@ -6,17 +6,21 @@ use serde::{Deserialize, Serialize};
 
 const ENV_VAR: &str = "POLYMARKET_PRIVATE_KEY";
 const SIG_TYPE_ENV_VAR: &str = "POLYMARKET_SIGNATURE_TYPE";
+const PROXY_ENV_VAR: &str = "POLYMARKET_PROXY";
 pub const DEFAULT_SIGNATURE_TYPE: &str = "proxy";
 
 pub const NO_WALLET_MSG: &str =
     "No wallet configured. Run `polymarket wallet create` or `polymarket wallet import <key>`";
 
 #[derive(Serialize, Deserialize)]
 pub struct Config {
+    #[serde(default)]
     pub private_key: String,
     pub chain_id: u64,
     #[serde(default = "default_signature_type")]
     pub signature_type: String,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub proxy: Option<String>,
 }
 
 fn default_signature_type() -> String {
@@ -94,10 +98,14 @@ pub fn save_wallet(key: &str, chain_id: u64, signature_type: &str) -> Result<()>
         fs::set_permissions(&dir, fs::Permissions::from_mode(0o700))?;
     }
 
+    // Preserve existing proxy setting from config file
+    let existing_proxy = load_config().and_then(|c| c.proxy);
+
     let config = Config {
         private_key: key.to_string(),
         chain_id,
         signature_type: signature_type.to_string(),
+        proxy: existing_proxy,
     };
     let json = serde_json::to_string_pretty(&config)?;
     let path = config_path()?;
@@ -125,6 +133,22 @@ pub fn save_wallet(key: &str, chain_id: u64, signature_type: &str) -> Result<()>
     Ok(())
 }
 
+
+/// Priority: CLI flag > env var > config file.
+pub fn resolve_proxy(cli_flag: Option<&str>) -> Option<String> {
+    if let Some(url) = cli_flag {
+        return Some(url.to_string());
+    }
+    if let Ok(url) = std::env::var(PROXY_ENV_VAR)
+        && !url.is_empty()
+    {
+        return Some(url);
+    }
+    if let Some(config) = load_config() {
+        return config.proxy;
+    }
+    None
+}
 /// Priority: CLI flag > env var > config file.
 pub fn resolve_key(cli_flag: Option<&str>) -> (Option<String>, KeySource) {
     if let Some(key) = cli_flag {
@@ -136,7 +160,9 @@ pub fn resolve_key(cli_flag: Option<&str>) -> (Option<String>, KeySource) {
         return (Some(key), KeySource::EnvVar);
     }
     if let Some(config) = load_config() {
-        return (Some(config.private_key), KeySource::ConfigFile);
+        if !config.private_key.is_empty() {
+            return (Some(config.private_key), KeySource::ConfigFile);
+        }
     }
     (None, KeySource::None)
 }

src/main.rs

@@ -26,6 +26,10 @@ pub(crate) struct Cli {
     /// Signature type: eoa, proxy, or gnosis-safe
     #[arg(long, global = true)]
     signature_type: Option<String>,
+
+    /// SOCKS5 or HTTP proxy URL (e.g., socks5://127.0.0.1:1080)
+    #[arg(long, global = true)]
+    proxy: Option<String>,
 }
 
 #[derive(Subcommand)]
@@ -66,12 +70,32 @@ enum Commands {
     Upgrade,
 }
 
-#[tokio::main]
-async fn main() -> ExitCode {
+fn main() -> ExitCode {
+    // Resolve proxy BEFORE tokio spawns worker threads.
+    // Parse CLI args early (sync) to get --proxy flag.
     let cli = Cli::parse();
+
+    // Apply proxy: --proxy flag > POLYMARKET_PROXY env > config file proxy field.
+    // Only set HTTP(S)_PROXY for CLOB/Gamma API calls.
+    // Exclude the Polygon RPC so alloy (which uses reqwest 0.12 without socks
+    // support) can still reach the RPC directly.
+    if let Some(ref url) = config::resolve_proxy(cli.proxy.as_deref()) {
+        // SAFETY: no threads exist yet — called before tokio runtime is built.
+        unsafe {
+            std::env::set_var("HTTPS_PROXY", url);
+            std::env::set_var("HTTP_PROXY", url);
+            std::env::set_var("NO_PROXY", "polygon.drpc.org,drpc.org");
+        }
+    }
+
     let output = cli.output;
 
-    if let Err(e) = run(cli).await {
+    let runtime = tokio::runtime::Builder::new_multi_thread()
+        .enable_all()
+        .build()
+        .expect("Failed to build tokio runtime");
+
+    if let Err(e) = runtime.block_on(run(cli)) {
         match output {
             OutputFormat::Json => {
                 println!("{}", serde_json::json!({"error": e.to_string()}));