Error Handling

async function recoverPendingCommits(userKeypair: Keypair) {
  const timestamp    = Date.now().toString();
  const signature    = signMessage(`read:${timestamp}`, userKeypair);
  const user_address = userKeypair.publicKey.toBase58();

  const pairs: [string, string, object][] = [
    ['/account/pending', '/commit',        { user_address, timestamp, signature }],
    // the lending reads take the same read message as `user_signature`
    ['/borrow/pending',  '/borrow/commit', { user_address, timestamp, user_signature: signature }],
  ];

  for (const [pendingPath, commitPath, body] of pairs) {
    const pending = await vanish(pendingPath, { method: 'POST', body: JSON.stringify(body) });

    for (const action of pending) {
      const commit = await vanish(commitPath, {
        method: 'POST',
        body: JSON.stringify({ tx_id: action.tx_id }),
      });
      // already_processed: true means it was already committed - safe to skip
      if (!commit.already_processed) {
        console.log(`Resolved ${action.action_type}:`, commit.status);
      }
    }
  }
}

async fn recover_pending_commits(
    client: &Client,
    api_key: &str,
    user_keypair: &Keypair,
) -> Result<(), reqwest::Error> {
    let timestamp = chrono::Utc::now().timestamp_millis().to_string();
    let address   = user_keypair.pubkey().to_string();
    let signature = sign_message(&format!("read:{timestamp}"), user_keypair);

    // same read message either way - only the field name differs
    let account_body = serde_json::json!({
        "user_address": &address, "timestamp": &timestamp, "signature": &signature,
    });
    let borrow_body = serde_json::json!({
        "user_address": &address, "timestamp": &timestamp, "user_signature": &signature,
    });

    for (pending_path, commit_path, body) in [
        ("/account/pending", "/commit", &account_body),
        ("/borrow/pending", "/borrow/commit", &borrow_body),
    ] {
        let pending = vanish(client, api_key, pending_path, Some(body)).await?;

        for action in pending.as_array().unwrap_or(&vec![]) {
            let commit_body = serde_json::json!({ "tx_id": action["tx_id"] });
            let commit = vanish(client, api_key, commit_path, Some(&commit_body)).await?;

            if !commit["already_processed"].as_bool().unwrap_or(false) {
                println!("Resolved {}: {}", action["action_type"], commit["status"]);
            }
        }
    }

    Ok(())
}

async function checkHealth(): Promise<boolean> {
  const res = await fetch('https://core-api.vanish.trade/health', {
    headers: { 'x-api-key': process.env.VANISH_API_KEY! },
  });
  return res.ok; // true if 200 "healthy"
}

async fn check_health(client: &Client, api_key: &str) -> bool {
    client
        .get(format!("{}/health", VANISH_URL))
        .header("x-api-key", api_key)
        .send()
        .await
        .map(|r| r.status().is_success())
        .unwrap_or(false)
}