quicknode-cli 0.6.0

//! Integration tests for `qn rpc`.
//!
//! The in-process harness injects `--api-key test`; the token cache is keyed by
//! account id via a `sha256(key) -> account_id -> token` lookup. Tests that
//! exercise the cache pass `--config-file` so `tokens.toml` lands in a tempdir
//! rather than the real home.

mod common;

use common::run_qn;
use serde_json::json;
use std::sync::atomic::{AtomicUsize, Ordering};
use wiremock::matchers::{body_partial_json, method, path};
use wiremock::{Mock, MockServer, Request, Respond, ResponseTemplate};

// SHA-256 of "test" (the harness-injected API key).
const TEST_KEY_HASH: &str = "9f86d081884c7d659a2feaa0c55ad015a3bf4f1b2b0b822cd15d6c15b0f00a08";

// The account id used across the cache tests.
const TEST_ACCOUNT_ID: i64 = 12345;

// A far-future ISO timestamp so a freshly minted token is never near expiry.
const FUTURE_ISO: &str = "2099-01-01T00:00:00.000Z";
// Matching far-future unix seconds for a seeded token.
const FUTURE_UNIX: i64 = 4_070_908_800;

/// Writes a `tokens.toml` in the new two-level shape: `key_hash -> account_id`
/// and `account_id -> token`. A hit on `key_hash` resolves the account offline.
fn write_token_cache(dir: &tempfile::TempDir, endpoint_url: &str, key_hash: &str, account_id: i64) {
    let path = dir.path().join("tokens.toml");
    let body = format!(
        "[keys]\n\"{key_hash}\" = {account_id}\n\n\
         [tokens.{account_id}]\nendpoint_url = \"{endpoint_url}\"\n\
         token = \"seeded.jwt\"\nexp_unix = {FUTURE_UNIX}\n"
    );
    std::fs::write(&path, body).unwrap();
}

/// Mounts a `GET /v0/account/info` returning `TEST_ACCOUNT_ID`, asserting it is
/// called exactly `times`. Cache misses need it (to key the write-back by
/// account); cache hits must never call it.
async fn mount_account_info(server: &MockServer, times: u64) {
    Mock::given(method("GET"))
        .and(path("/v0/account/info"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": {
                "id": TEST_ACCOUNT_ID,
                "name": "Acme Inc",
                "created_at": "2024-01-01T00:00:00Z",
                "billing_version": "v6",
                "subscription": null
            }
        })))
        .expect(times)
        .mount(server)
        .await;
}

fn cfg_path(dir: &tempfile::TempDir) -> String {
    // Provide an API key via the config file so the cache parent dir is the
    // tempdir. The harness still injects --api-key test, which wins, so the
    // cache key_hash matches TEST_KEY_HASH.
    let path = dir.path().join("config.toml");
    std::fs::write(&path, "[api]\nkey = \"test\"\n").unwrap();
    path.to_str().unwrap().to_string()
}

#[tokio::test]
async fn seeded_token_skips_mint() {
    let server = MockServer::start().await;
    // RPC endpoint returns a result. The mint route is intentionally NOT
    // mounted: if the SDK tried to mint, the call would 404 and fail.
    Mock::given(method("POST"))
        .and(path("/rpc"))
        .and(body_partial_json(json!({ "method": "eth_blockNumber" })))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1, "result": "0x1335f9a"
        })))
        .expect(1)
        .mount(&server)
        .await;
    // A cache hit must resolve the account offline: account_info is never called.
    mount_account_info(&server, 0).await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    write_token_cache(
        &dir,
        &format!("{}/rpc", server.uri()),
        TEST_KEY_HASH,
        TEST_ACCOUNT_ID,
    );

    let out = run_qn(
        &server.uri(),
        &["--config-file", &cfg, "rpc", "call", "eth_blockNumber"],
    )
    .await;
    assert_eq!(out.exit_code, 0, "stderr={}", out.stderr);
}

// An already-enabled call must NOT incur the post-enable provisioning wait,
// even with --yes. --yes only matters if Tooling Access is disabled; here the
// seeded token works on the first attempt, so the ~1s wait must not fire.
#[tokio::test]
async fn already_enabled_yes_does_not_wait() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/rpc"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1, "result": "0x1"
        })))
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    write_token_cache(
        &dir,
        &format!("{}/rpc", server.uri()),
        TEST_KEY_HASH,
        TEST_ACCOUNT_ID,
    );

    let started = std::time::Instant::now();
    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "eth_blockNumber",
            "--yes",
        ],
    )
    .await;
    let elapsed = started.elapsed();
    assert_eq!(out.exit_code, 0, "stderr={}", out.stderr);
    // The post-enable initial wait is 1s; a happy-path call must be far faster.
    assert!(
        elapsed < std::time::Duration::from_millis(500),
        "already-enabled --yes should not wait, took {elapsed:?}"
    );
}

#[tokio::test]
async fn no_cache_mints_then_calls() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/v0/tooling-access/token"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": {
                "endpoint_url": format!("{}/rpc", server.uri()),
                "token": "minted.jwt",
                "expires_at": FUTURE_ISO
            },
            "error": null
        })))
        .expect(1)
        .mount(&server)
        .await;
    Mock::given(method("POST"))
        .and(path("/rpc"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1, "result": "0xabc"
        })))
        .expect(1)
        .mount(&server)
        .await;
    // A miss (unknown key) learns the account id once to key the write-back.
    mount_account_info(&server, 1).await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    let out = run_qn(
        &server.uri(),
        &["--config-file", &cfg, "rpc", "call", "eth_blockNumber"],
    )
    .await;
    assert_eq!(out.exit_code, 0, "stderr={}", out.stderr);

    // The minted token should have been written back under the account id, with
    // the key -> account mapping recorded, and never the API key itself.
    let cached = std::fs::read_to_string(dir.path().join("tokens.toml")).unwrap();
    assert!(cached.contains("minted.jwt"), "cache: {cached}");
    assert!(
        cached.contains(&format!("[tokens.{TEST_ACCOUNT_ID}]")),
        "token keyed by account id: {cached}"
    );
    assert!(
        cached.contains(TEST_KEY_HASH),
        "key mapping recorded: {cached}"
    );
    assert!(
        !cached.contains("\"test\""),
        "api key must not be stored: {cached}"
    );
}

#[tokio::test]
async fn json_rpc_error_exits_nonzero() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/rpc"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1,
            "error": { "code": -32602, "message": "invalid params" }
        })))
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    write_token_cache(
        &dir,
        &format!("{}/rpc", server.uri()),
        TEST_KEY_HASH,
        TEST_ACCOUNT_ID,
    );

    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "eth_getBalance",
            "[\"bad\"]",
        ],
    )
    .await;
    // SdkError::Rpc is neither Api nor Http → generic exit 1.
    assert_eq!(out.exit_code, 1, "stderr={}", out.stderr);
}

#[tokio::test]
async fn not_enabled_without_yes_is_actionable_error() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/v0/tooling-access/token"))
        .respond_with(ResponseTemplate::new(400).set_body_json(json!({
            "data": null,
            "error": "Tooling access is not enabled. Enable it first."
        })))
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    // No --yes, and the harness sets --no-input, so we can't prompt → the
    // command should fail with the actionable "run 'qn tooling-access enable'".
    let out = run_qn(
        &server.uri(),
        &["--config-file", &cfg, "rpc", "call", "eth_blockNumber"],
    )
    .await;
    assert_eq!(out.exit_code, 1, "stderr={}", out.stderr);
    assert!(
        out.stderr.contains("tooling-access enable"),
        "stderr={}",
        out.stderr
    );
}

#[tokio::test]
async fn not_enabled_with_yes_auto_enables_and_retries() {
    let server = MockServer::start().await;

    // Mint: first call 400 (not enabled), subsequent calls succeed.
    struct MintSeq {
        calls: AtomicUsize,
        url: String,
    }
    impl Respond for MintSeq {
        fn respond(&self, _: &Request) -> ResponseTemplate {
            let n = self.calls.fetch_add(1, Ordering::SeqCst);
            if n == 0 {
                ResponseTemplate::new(400).set_body_json(json!({
                    "data": null,
                    "error": "Tooling access is not enabled. Enable it first."
                }))
            } else {
                ResponseTemplate::new(200).set_body_json(json!({
                    "data": { "endpoint_url": self.url, "token": "minted.jwt", "expires_at": FUTURE_ISO },
                    "error": null
                }))
            }
        }
    }

    Mock::given(method("POST"))
        .and(path("/v0/tooling-access/token"))
        .respond_with(MintSeq {
            calls: AtomicUsize::new(0),
            url: format!("{}/rpc", server.uri()),
        })
        .mount(&server)
        .await;
    // enable_tooling_access PATCH.
    Mock::given(method("PATCH"))
        .and(path("/v0/tooling-access"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": { "enabled": true, "endpoint_url": format!("{}/rpc", server.uri()) },
            "error": null
        })))
        .expect(1)
        .mount(&server)
        .await;
    Mock::given(method("POST"))
        .and(path("/rpc"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1, "result": "0xok"
        })))
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "eth_blockNumber",
            "--yes",
        ],
    )
    .await;
    assert_eq!(out.exit_code, 0, "stderr={}", out.stderr);
}

#[tokio::test]
async fn unknown_key_mints_and_preserves_other_account() {
    let server = MockServer::start().await;
    // The cache holds a token for a DIFFERENT key/account. Our key isn't in
    // `[keys]`, so this is a miss: mint, learn our account id, and store under it
    // without disturbing the other account's entry.
    Mock::given(method("POST"))
        .and(path("/v0/tooling-access/token"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": {
                "endpoint_url": format!("{}/rpc", server.uri()),
                "token": "minted.jwt",
                "expires_at": FUTURE_ISO
            },
            "error": null
        })))
        .expect(1)
        .mount(&server)
        .await;
    Mock::given(method("POST"))
        .and(path("/rpc"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1, "result": "0xok"
        })))
        .mount(&server)
        .await;
    // A miss learns our account id once.
    mount_account_info(&server, 1).await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    // Pre-seed a different account (id 999) under a different key hash.
    let other_id = 999;
    write_token_cache(&dir, &format!("{}/rpc", server.uri()), "deadbeef", other_id);

    let out = run_qn(
        &server.uri(),
        &["--config-file", &cfg, "rpc", "call", "eth_blockNumber"],
    )
    .await;
    assert_eq!(out.exit_code, 0, "stderr={}", out.stderr);

    // Both accounts now coexist in the shared file: ours (freshly minted) and
    // the pre-existing one (untouched).
    let cached = std::fs::read_to_string(dir.path().join("tokens.toml")).unwrap();
    assert!(
        cached.contains(&format!("[tokens.{TEST_ACCOUNT_ID}]")),
        "our account cached: {cached}"
    );
    assert!(
        cached.contains(&format!("[tokens.{other_id}]")),
        "other account preserved: {cached}"
    );
}

// A cached token pointing at an unreachable (disabled) endpoint yields a
// connect failure; the CLI probes status, sees disabled, clears the stale
// token, and routes into the same enable flow as the mint-400 path. In the
// harness (non-TTY + --no-input, no --yes) that flow can't prompt, so it ends
// in the actionable "run qn tooling-access enable" error.
#[tokio::test]
async fn connect_failure_with_disabled_status_prompts_to_enable() {
    let server = MockServer::start().await;
    // Status probe reports disabled.
    Mock::given(method("GET"))
        .and(path("/v0/tooling-access"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": { "enabled": false, "endpoint_url": null, "endpoint_id": 3 },
            "error": null
        })))
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    // Seed a still-valid token whose endpoint_url refuses connections fast
    // (loopback, almost-certainly-closed high port) so the RPC POST returns a
    // connect error promptly rather than waiting out the timeout.
    write_token_cache(
        &dir,
        "http://127.0.0.1:9/rpc",
        TEST_KEY_HASH,
        TEST_ACCOUNT_ID,
    );

    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "eth_blockNumber",
            "--retries",
            "0",
        ],
    )
    .await;
    assert_ne!(out.exit_code, 0, "should fail");
    // Same actionable message as the mint-400 path (both converge on enable).
    assert!(
        out.stderr.contains("tooling-access enable"),
        "expected enable guidance, got: {}",
        out.stderr
    );
    // The stale token entry for this account should have been dropped before the
    // enable attempt, while the file (and its key -> account mapping) remains.
    let cached = std::fs::read_to_string(dir.path().join("tokens.toml")).unwrap();
    assert!(
        !cached.contains(&format!("[tokens.{TEST_ACCOUNT_ID}]")),
        "stale account token should be cleared: {cached}"
    );
    assert!(
        cached.contains(TEST_KEY_HASH),
        "key mapping preserved: {cached}"
    );
}

// With --yes, the connect-failure-disabled path auto-enables and retries the
// call against the (now re-enabled) endpoint, minting a fresh token.
#[tokio::test]
async fn connect_failure_with_disabled_status_auto_enables_with_yes() {
    let server = MockServer::start().await;
    // Status reports disabled (drives the connect-failure path into enable).
    Mock::given(method("GET"))
        .and(path("/v0/tooling-access"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": { "enabled": false, "endpoint_url": null, "endpoint_id": 3 },
            "error": null
        })))
        .mount(&server)
        .await;
    // enable() PATCH succeeds.
    Mock::given(method("PATCH"))
        .and(path("/v0/tooling-access"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": { "enabled": true, "endpoint_url": format!("{}/rpc", server.uri()), "endpoint_id": 3 },
            "error": null
        })))
        .expect(1)
        .mount(&server)
        .await;
    // After enabling, the retry re-mints (the stale token was cleared) and the
    // fresh token points at the reachable /rpc mock.
    Mock::given(method("POST"))
        .and(path("/v0/tooling-access/token"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": { "endpoint_url": format!("{}/rpc", server.uri()), "token": "minted.jwt", "expires_at": FUTURE_ISO },
            "error": null
        })))
        .mount(&server)
        .await;
    Mock::given(method("POST"))
        .and(path("/rpc"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1, "result": "0xok"
        })))
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    write_token_cache(
        &dir,
        "http://127.0.0.1:9/rpc",
        TEST_KEY_HASH,
        TEST_ACCOUNT_ID,
    );

    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "eth_blockNumber",
            "--retries",
            "0",
            "--yes",
        ],
    )
    .await;
    assert_eq!(out.exit_code, 0, "stderr={}", out.stderr);
}

// --network: status returns an id, get_endpoint_urls returns the per-network
// map, and the RPC call routes to the mapped (solana) URL, not the default.
#[tokio::test]
async fn network_routes_to_mapped_url() {
    let server = MockServer::start().await;
    let solana_url = format!("{}/solana", server.uri());

    Mock::given(method("GET"))
        .and(path("/v0/tooling-access"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": { "enabled": true, "endpoint_url": format!("{}/default", server.uri()), "endpoint_id": 3 },
            "error": null
        })))
        .mount(&server)
        .await;
    Mock::given(method("GET"))
        .and(path("/v0/endpoints/3/urls"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": {
                "http_url": format!("{}/default", server.uri()),
                "wss_url": null,
                "multichain_urls": {
                    "solana-mainnet": { "http_url": solana_url, "wss_url": null }
                }
            },
            "error": null
        })))
        .mount(&server)
        .await;
    // The call must hit /solana. /default is not mounted, so a misroute 404s.
    Mock::given(method("POST"))
        .and(path("/solana"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1, "result": "12345"
        })))
        .expect(1)
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    write_token_cache(
        &dir,
        &format!("{}/default", server.uri()),
        TEST_KEY_HASH,
        TEST_ACCOUNT_ID,
    );

    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "getSlot",
            "--network",
            "solana-mainnet",
        ],
    )
    .await;
    assert_eq!(out.exit_code, 0, "stderr={}", out.stderr);

    // networks.toml was written for reuse.
    let cached = std::fs::read_to_string(dir.path().join("networks.toml")).unwrap();
    assert!(cached.contains("solana-mainnet"), "cache: {cached}");
}

// --network when Tooling Access is disabled routes through the enable gate.
// In the harness (non-TTY + --no-input) without --yes that gate can't prompt,
// so it ends in the actionable "run qn tooling-access enable" error (exit 5)
// and no URL-map fetch or RPC call is made.
#[tokio::test]
async fn network_when_disabled_without_yes_prompts_to_enable() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/v0/tooling-access"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": { "enabled": false, "endpoint_url": null, "endpoint_id": null },
            "error": null
        })))
        .mount(&server)
        .await;
    // No enable, no URL-map fetch, no RPC call should be reached.
    Mock::given(method("PATCH"))
        .and(path("/v0/tooling-access"))
        .respond_with(ResponseTemplate::new(200))
        .expect(0)
        .mount(&server)
        .await;
    Mock::given(method("GET"))
        .and(path("/v0/endpoints/3/urls"))
        .respond_with(ResponseTemplate::new(200))
        .expect(0)
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "getSlot",
            "--network",
            "solana-mainnet",
        ],
    )
    .await;
    assert_ne!(out.exit_code, 0, "should fail");
    // Same actionable message as the default lane's mint-400 path.
    assert!(
        out.stderr.contains("tooling-access enable"),
        "expected enable hint, got: {}",
        out.stderr
    );
}

// --network when disabled + --yes: enable, re-fetch status (now enabled with an
// id), fetch the per-network map, and route the call to the mapped URL.
#[tokio::test]
async fn network_when_disabled_with_yes_enables_and_routes() {
    let server = MockServer::start().await;
    let solana_url = format!("{}/solana", server.uri());

    // Status flips to enabled after the enable PATCH: first GET reports disabled,
    // subsequent GETs report enabled with an id.
    struct StatusSeq {
        calls: AtomicUsize,
        default_url: String,
    }
    impl wiremock::Respond for StatusSeq {
        fn respond(&self, _: &wiremock::Request) -> ResponseTemplate {
            let n = self.calls.fetch_add(1, Ordering::SeqCst);
            if n == 0 {
                ResponseTemplate::new(200).set_body_json(json!({
                    "data": { "enabled": false, "endpoint_url": null, "endpoint_id": null },
                    "error": null
                }))
            } else {
                ResponseTemplate::new(200).set_body_json(json!({
                    "data": { "enabled": true, "endpoint_url": self.default_url, "endpoint_id": 3 },
                    "error": null
                }))
            }
        }
    }
    Mock::given(method("GET"))
        .and(path("/v0/tooling-access"))
        .respond_with(StatusSeq {
            calls: AtomicUsize::new(0),
            default_url: format!("{}/default", server.uri()),
        })
        .mount(&server)
        .await;
    Mock::given(method("PATCH"))
        .and(path("/v0/tooling-access"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": { "enabled": true, "endpoint_url": format!("{}/default", server.uri()) },
            "error": null
        })))
        .expect(1)
        .mount(&server)
        .await;
    Mock::given(method("GET"))
        .and(path("/v0/endpoints/3/urls"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": {
                "http_url": format!("{}/default", server.uri()),
                "wss_url": null,
                "multichain_urls": {
                    "solana-mainnet": { "http_url": solana_url, "wss_url": null }
                }
            },
            "error": null
        })))
        .mount(&server)
        .await;
    Mock::given(method("POST"))
        .and(path("/solana"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1, "result": "12345"
        })))
        .expect(1)
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    // Seed a cached token so the call uses it rather than minting (the enable
    // flow, not token acquisition, is what this test exercises).
    write_token_cache(
        &dir,
        &format!("{}/default", server.uri()),
        TEST_KEY_HASH,
        TEST_ACCOUNT_ID,
    );

    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "getSlot",
            "--network",
            "solana-mainnet",
            "--yes",
        ],
    )
    .await;
    assert_eq!(out.exit_code, 0, "stderr={}", out.stderr);
}

// --list-networks prints the available keys without making an RPC call.
#[tokio::test]
async fn list_networks_prints_keys() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/v0/tooling-access"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": { "enabled": true, "endpoint_url": format!("{}/default", server.uri()), "endpoint_id": 3 },
            "error": null
        })))
        .mount(&server)
        .await;
    Mock::given(method("GET"))
        .and(path("/v0/endpoints/3/urls"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": {
                "http_url": format!("{}/default", server.uri()),
                "multichain_urls": {
                    "solana-mainnet": { "http_url": "https://x/sol", "wss_url": null },
                    "polygon": { "http_url": "https://x/matic", "wss_url": null }
                }
            },
            "error": null
        })))
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    write_token_cache(
        &dir,
        &format!("{}/default", server.uri()),
        TEST_KEY_HASH,
        TEST_ACCOUNT_ID,
    );

    let out = run_qn(
        &server.uri(),
        &["--config-file", &cfg, "rpc", "list-networks"],
    )
    .await;
    assert_eq!(out.exit_code, 0, "stderr={}", out.stderr);
}

// Unknown --network surfaces a CLI error that points at `qn rpc list-networks`
// (the SDK's raw "unknown network" message is intercepted and re-rendered).
#[tokio::test]
async fn unknown_network_errors() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/v0/tooling-access"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": { "enabled": true, "endpoint_url": format!("{}/default", server.uri()), "endpoint_id": 3 },
            "error": null
        })))
        .mount(&server)
        .await;
    Mock::given(method("GET"))
        .and(path("/v0/endpoints/3/urls"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "data": {
                "http_url": format!("{}/default", server.uri()),
                "multichain_urls": {
                    "solana-mainnet": { "http_url": "https://x/sol", "wss_url": null }
                }
            },
            "error": null
        })))
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    write_token_cache(
        &dir,
        &format!("{}/default", server.uri()),
        TEST_KEY_HASH,
        TEST_ACCOUNT_ID,
    );

    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "getSlot",
            "--network",
            "nope-mainnet",
        ],
    )
    .await;
    assert_ne!(out.exit_code, 0, "should fail on unknown network");
    // The CLI-rendered message keeps the available-keys list and points the
    // user at the discovery command, dropping the SDK-internal seeding hint.
    assert!(
        out.stderr.contains("qn rpc list-networks"),
        "expected list-networks hint, got: {}",
        out.stderr
    );
    assert!(
        out.stderr.contains("solana-mainnet"),
        "expected available keys, got: {}",
        out.stderr
    );
}

// A custom --endpoint-url sends the call straight to that URL. No token is
// minted (the mint route is not mounted, so a stray mint would 404) and the
// call succeeds against the custom host.
#[tokio::test]
async fn endpoint_url_flag_routes_call_without_minting() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/custom/rpc"))
        .and(body_partial_json(json!({ "method": "eth_blockNumber" })))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1, "result": "0xcafe"
        })))
        .expect(1)
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    let url = format!("{}/custom/rpc", server.uri());
    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "eth_blockNumber",
            "--endpoint-url",
            &url,
        ],
    )
    .await;
    assert_eq!(out.exit_code, 0, "stderr={}", out.stderr);

    // Custom-URL lane never mints, so nothing is written to the token cache.
    assert!(
        !dir.path().join("tokens.toml").exists(),
        "custom-URL call must not write a token cache"
    );
}

// `[rpc] endpoint_url` in the config file routes a call there with no flag.
#[tokio::test]
async fn config_endpoint_url_routes_call() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/from-config/rpc"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1, "result": "0x1"
        })))
        .expect(1)
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let path = dir.path().join("config.toml");
    let url = format!("{}/from-config/rpc", server.uri());
    std::fs::write(
        &path,
        format!("[api]\nkey = \"test\"\n\n[rpc]\nendpoint_url = \"{url}\"\n"),
    )
    .unwrap();
    let cfg = path.to_str().unwrap();

    let out = run_qn(
        &server.uri(),
        &["--config-file", cfg, "rpc", "call", "eth_blockNumber"],
    )
    .await;
    assert_eq!(out.exit_code, 0, "stderr={}", out.stderr);
}

// A per-call --endpoint-url overrides the config-file default.
#[tokio::test]
async fn flag_endpoint_url_overrides_config() {
    let server = MockServer::start().await;
    // Only the flag's URL is mounted; the config URL would 404 if used.
    Mock::given(method("POST"))
        .and(path("/flag/rpc"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1, "result": "0x1"
        })))
        .expect(1)
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let path = dir.path().join("config.toml");
    let cfg_url = format!("{}/config/rpc", server.uri());
    std::fs::write(
        &path,
        format!("[api]\nkey = \"test\"\n\n[rpc]\nendpoint_url = \"{cfg_url}\"\n"),
    )
    .unwrap();
    let cfg = path.to_str().unwrap();
    let flag_url = format!("{}/flag/rpc", server.uri());

    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            cfg,
            "rpc",
            "call",
            "eth_blockNumber",
            "--endpoint-url",
            &flag_url,
        ],
    )
    .await;
    assert_eq!(out.exit_code, 0, "stderr={}", out.stderr);
}

// A failing custom-URL call surfaces the error directly: it must NOT probe
// Tooling Access status or attempt to enable it. Both admin endpoints assert
// zero hits.
#[tokio::test]
async fn custom_url_failure_bypasses_enable_recovery() {
    let server = MockServer::start().await;
    // The custom endpoint returns a JSON-RPC error (a real, non-transport failure).
    Mock::given(method("POST"))
        .and(path("/custom/rpc"))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1,
            "error": { "code": -32601, "message": "method not found" }
        })))
        .mount(&server)
        .await;
    // The Tooling Access status probe and enable must never be reached.
    Mock::given(method("GET"))
        .and(path("/v0/tooling-access"))
        .respond_with(ResponseTemplate::new(200))
        .expect(0)
        .mount(&server)
        .await;
    Mock::given(method("PATCH"))
        .and(path("/v0/tooling-access"))
        .respond_with(ResponseTemplate::new(200))
        .expect(0)
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    let url = format!("{}/custom/rpc", server.uri());
    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "eth_blockNumber",
            "--endpoint-url",
            &url,
        ],
    )
    .await;
    assert_ne!(out.exit_code, 0, "custom-URL JSON-RPC error should fail");
}

// A malformed --endpoint-url is rejected before any request is made.
#[tokio::test]
async fn endpoint_url_rejects_bad_scheme() {
    let server = MockServer::start().await;
    // Nothing should be requested.
    Mock::given(method("POST"))
        .and(path("/rpc"))
        .respond_with(ResponseTemplate::new(200))
        .expect(0)
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "eth_blockNumber",
            "--endpoint-url",
            "ftp://example.com/rpc",
        ],
    )
    .await;
    assert_ne!(out.exit_code, 0, "bad scheme should be rejected");
    assert!(
        out.stderr.contains("http or https"),
        "stderr={}",
        out.stderr
    );
}

// --endpoint-url and --network are mutually exclusive at the clap layer; the
// parse error fires before any request.
#[tokio::test]
async fn endpoint_url_conflicts_with_network() {
    let server = MockServer::start().await;
    Mock::given(method("GET"))
        .and(path("/v0/tooling-access"))
        .respond_with(ResponseTemplate::new(200))
        .expect(0)
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "eth_blockNumber",
            "--endpoint-url",
            "https://x/rpc",
            "--network",
            "solana-mainnet",
        ],
    )
    .await;
    assert_ne!(out.exit_code, 0, "conflicting flags should fail to parse");
}

// --params-file reads the JSON params from a file; the parsed params reach the
// request body just like an inline positional value would.
#[tokio::test]
async fn params_file_reads_json_from_file() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/rpc"))
        .and(body_partial_json(json!({
            "method": "eth_getBalance",
            "params": ["0xabc", "latest"]
        })))
        .respond_with(ResponseTemplate::new(200).set_body_json(json!({
            "jsonrpc": "2.0", "id": 1, "result": "0x0"
        })))
        .expect(1)
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    write_token_cache(
        &dir,
        &format!("{}/rpc", server.uri()),
        TEST_KEY_HASH,
        TEST_ACCOUNT_ID,
    );
    let params_path = dir.path().join("params.json");
    std::fs::write(&params_path, r#"["0xabc", "latest"]"#).unwrap();
    let params_file = params_path.to_str().unwrap();

    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "eth_getBalance",
            "--params-file",
            params_file,
        ],
    )
    .await;
    assert_eq!(out.exit_code, 0, "stderr={}", out.stderr);
}

// A missing --params-file path fails with an actionable error before any call.
#[tokio::test]
async fn params_file_missing_path_errors() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/rpc"))
        .respond_with(ResponseTemplate::new(200))
        .expect(0)
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    write_token_cache(
        &dir,
        &format!("{}/rpc", server.uri()),
        TEST_KEY_HASH,
        TEST_ACCOUNT_ID,
    );
    let missing = dir.path().join("does-not-exist.json");

    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "eth_getBalance",
            "-f",
            missing.to_str().unwrap(),
        ],
    )
    .await;
    assert_ne!(out.exit_code, 0, "missing params file should fail");
    assert!(
        out.stderr.contains("could not read params file"),
        "stderr={}",
        out.stderr
    );
}

// The positional params and --params-file are mutually exclusive at the clap
// layer; passing both fails to parse before any request.
#[tokio::test]
async fn params_positional_and_file_conflict() {
    let server = MockServer::start().await;
    Mock::given(method("POST"))
        .and(path("/rpc"))
        .respond_with(ResponseTemplate::new(200))
        .expect(0)
        .mount(&server)
        .await;

    let dir = tempfile::tempdir().unwrap();
    let cfg = cfg_path(&dir);
    write_token_cache(
        &dir,
        &format!("{}/rpc", server.uri()),
        TEST_KEY_HASH,
        TEST_ACCOUNT_ID,
    );
    let params_path = dir.path().join("params.json");
    std::fs::write(&params_path, "[]").unwrap();

    let out = run_qn(
        &server.uri(),
        &[
            "--config-file",
            &cfg,
            "rpc",
            "call",
            "eth_getBalance",
            "[\"inline\"]",
            "--params-file",
            params_path.to_str().unwrap(),
        ],
    )
    .await;
    assert_ne!(
        out.exit_code, 0,
        "positional + --params-file should conflict"
    );
}