Simplify: single network at boot via SOLANA_NETWORK env var

Remove runtime network switching. The app runs on one network
configured at boot (SOLANA_NETWORK=devnet|mainnet|testnet).

- Remove NetworksController and route
- Remove dropdown_controller.js
- Network badge is now display-only in nav
- All services read from SolanaConfig (no network params)
- Explorer links use SolanaConfig.explorer_base/explorer_cluster
- WalletPortfolioService and TokenMetadataService simplified (no network arg)
- Cleaner cache keys (no network prefix needed)

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: moviendome

app/controllers/application_controller.rb

@@ -3,7 +3,7 @@ class ApplicationController < ActionController::Base
 
   before_action :authenticate!
 
-  helper_method :current_user, :logged_in?, :current_network, :current_rpc_url
+  helper_method :current_user, :logged_in?
 
   private
 
@@ -18,12 +18,4 @@ def logged_in?
   def authenticate!
     redirect_to login_path unless logged_in?
   end
-
-  def current_network
-    session[:network] || "mainnet"
-  end
-
-  def current_rpc_url
-    SolanaConfig.rpc_url(current_network)
-  end
 end

app/controllers/dashboard_controller.rb

@@ -2,15 +2,13 @@ class DashboardController < ApplicationController
   def show
     @wallet_address = current_user.wallet_address
     @short_address = "#{@wallet_address[0..3]}...#{@wallet_address[-4..]}"
-    @network = current_network
 
-    portfolio = WalletPortfolioService.new(@wallet_address, network: @network)
+    portfolio = WalletPortfolioService.new(@wallet_address)
     @tokens = portfolio.tokens
     @total_usd = portfolio.total_usd_value
     @transactions = portfolio.recent_transactions
 
-    # Start background monitoring for new transactions
-    WalletMonitorJob.perform_later(@wallet_address, network: @network) unless monitoring?(@wallet_address)
+    WalletMonitorJob.perform_later(@wallet_address) unless monitoring?(@wallet_address)
   end
 
   private

app/controllers/networks_controller.rb

@@ -1,12 +1,9 @@
 class TransfersController < ApplicationController
-  # GET /transfers/new — Send SOL form
   def new
     @wallet_address = current_user.wallet_address
-    @network = current_network
-    @balance = SolanaClient.new(rpc_url: current_rpc_url).get_balance(@wallet_address)
+    @balance = SolanaClient.new.get_balance(@wallet_address)
   end
 
-  # POST /transfers — Validate and return transaction params for JS to build
   def create
     recipient = params[:recipient]&.strip
     amount_sol = params[:amount_sol].to_f
@@ -25,7 +22,7 @@ def create
 
     amount_lamports = (amount_sol * 1_000_000_000).to_i
 
-    client = SolanaClient.new(rpc_url: current_rpc_url)
+    client = SolanaClient.new
     balance = client.get_balance(current_user.wallet_address)
 
     if balance.nil? || (balance * 1_000_000_000).to_i < amount_lamports + 5000
@@ -41,7 +38,7 @@ def create
       recipient: recipient,
       amount_lamports: amount_lamports,
       amount_sol: amount_sol,
-      network: current_network,
+      network: SolanaConfig.network,
       status: "pending"
     )
 
@@ -51,11 +48,10 @@ def create
       recipient: recipient,
       amount_lamports: amount_lamports,
       blockhash: blockhash,
-      rpc_url: current_rpc_url
+      rpc_url: SolanaConfig.rpc_url
     }
   end
 
-  # PATCH /transfers/:id — Update with signature after wallet signs
   def update
     transfer = current_user.transfers.find(params[:id])
     signature = params[:signature]
@@ -70,13 +66,10 @@ def update
     render json: { success: true, transfer_id: transfer.id }
   end
 
-  # GET /transfers/:id — Show transfer detail
   def show
     @transfer = current_user.transfers.find(params[:id])
-    @network = current_network
   end
 
-  # GET /transfers/:id/status — Poll confirmation status
   def status
     transfer = current_user.transfers.find(params[:id])
     render json: {

app/controllers/transfers_controller.rb

@@ -10,9 +10,6 @@ application.register("auto-refresh", AutoRefreshController)
 import ClipboardController from "./clipboard_controller"
 application.register("clipboard", ClipboardController)
 
-import DropdownController from "./dropdown_controller"
-application.register("dropdown", DropdownController)
-
 import TransferController from "./transfer_controller"
 application.register("transfer", TransferController)
 

app/javascript/controllers/dropdown_controller.js

@@ -1,65 +1,60 @@
 # Starts a WebSocket subscription to Solana for real-time account changes.
 # Falls back to polling if WebSocket is unavailable.
+# Runs as long as the dashboard is open (re-triggered on page load).
 class WalletMonitorJob < ApplicationJob
   queue_as :default
 
   MONITOR_DURATION = 10.minutes
 
-  def perform(wallet_address, network: "mainnet")
+  def perform(wallet_address)
     cache_key = "wallet_monitor/#{wallet_address}/active"
-    return if Rails.cache.read(cache_key) # Already monitoring
+    return if Rails.cache.read(cache_key)
 
     Rails.cache.write(cache_key, true, expires_in: MONITOR_DURATION)
 
-    ws_url = ws_url_for(network)
-
+    ws_url = SolanaConfig.ws_url
     if ws_url.present?
-      monitor_via_websocket(wallet_address, network, ws_url)
+      monitor_via_websocket(wallet_address)
     else
-      monitor_via_polling(wallet_address, network)
+      monitor_via_polling(wallet_address)
     end
   ensure
     Rails.cache.delete("wallet_monitor/#{wallet_address}/active")
   end
 
   private
 
-  def monitor_via_websocket(wallet_address, network, ws_url)
-    monitor = SolanaWebsocketMonitor.new(wallet_address, network: network)
+  def monitor_via_websocket(wallet_address)
+    monitor = SolanaWebsocketMonitor.new(wallet_address)
     monitor.start
-
-    # Run for MONITOR_DURATION then stop
     sleep MONITOR_DURATION
     monitor.stop
   end
 
-  def monitor_via_polling(wallet_address, network, started_at: Time.current)
-    client = SolanaClient.new(rpc_url: SolanaConfig.rpc_url(network))
-
+  def monitor_via_polling(wallet_address, started_at: Time.current)
+    client = SolanaClient.new
     cache_key = "wallet_monitor/#{wallet_address}/last_sig"
+
     signatures = client.get_recent_signatures(wallet_address, limit: 1)
     latest_sig = signatures.first&.dig(:signature)
-
     previous_sig = Rails.cache.read(cache_key)
 
     if latest_sig && latest_sig != previous_sig
       Rails.cache.write(cache_key, latest_sig, expires_in: 1.hour)
-      broadcast_update(wallet_address, network) if previous_sig
+      broadcast_update(wallet_address) if previous_sig
     end
 
     if Time.current - started_at < MONITOR_DURATION
       sleep 15
-      monitor_via_polling(wallet_address, network, started_at: started_at)
+      monitor_via_polling(wallet_address, started_at: started_at)
     end
   end
 
-  def broadcast_update(wallet_address, network)
-    SolanaConfig::NETWORKS.each do |net|
-      Rails.cache.delete("wallet/#{net}/#{wallet_address}/tokens_v2")
-      Rails.cache.delete("wallet/#{net}/#{wallet_address}/recent_txs")
-    end
+  def broadcast_update(wallet_address)
+    Rails.cache.delete("wallet/#{wallet_address}/tokens")
+    Rails.cache.delete("wallet/#{wallet_address}/recent_txs")
 
-    portfolio = WalletPortfolioService.new(wallet_address, network: network)
+    portfolio = WalletPortfolioService.new(wallet_address)
     stream = "wallet_#{wallet_address}"
 
     Turbo::StreamsChannel.broadcast_replace_to(
@@ -74,17 +69,10 @@ def broadcast_update(wallet_address, network)
       locals: { tokens: portfolio.tokens }
     )
 
-    explorer_base = network == "mainnet" ? "https://solscan.io" : "https://explorer.solana.com"
-    explorer_cluster = network == "mainnet" ? "" : "?cluster=#{network}"
-
     Turbo::StreamsChannel.broadcast_replace_to(
       stream, target: "recent_activity",
       partial: "dashboard/recent_activity",
-      locals: { transactions: portfolio.recent_transactions, wallet_address: wallet_address, explorer_base: explorer_base, explorer_cluster: explorer_cluster }
+      locals: { transactions: portfolio.recent_transactions, wallet_address: wallet_address }
     )
   end
-
-  def ws_url_for(network)
-    SolanaConfig.ws_url(network)
-  end
 end

app/javascript/controllers/index.js

@@ -1,19 +1,29 @@
 # Single source of truth for Solana network configuration.
-# Reads from config/solana.yml which pulls from environment variables.
+# Network is set at boot via SOLANA_NETWORK env var (default: mainnet).
 class SolanaConfig
-  NETWORKS = %w[mainnet devnet testnet].freeze
-
   class << self
-    def rpc_url(network = "mainnet")
+    def network
+      config["network"]
+    end
+
+    def rpc_url
       config.dig("networks", network, "rpc_url")
     end
 
-    def ws_url(network = "mainnet")
+    def ws_url
       config.dig("networks", network, "ws_url")
     end
 
-    def valid_network?(network)
-      NETWORKS.include?(network)
+    def mainnet?
+      network == "mainnet"
+    end
+
+    def explorer_base
+      mainnet? ? "https://solscan.io" : "https://explorer.solana.com"
+    end
+
+    def explorer_cluster
+      mainnet? ? "" : "?cluster=#{network}"
     end
 
     private

app/jobs/wallet_monitor_job.rb

@@ -2,14 +2,13 @@
 require "websocket-client-simple"
 
 # Subscribes to Solana WebSocket RPC for real-time account changes.
-# Runs as a background thread and broadcasts updates via Turbo Streams.
+# Broadcasts updates via Turbo Streams when the account balance changes.
 class SolanaWebsocketMonitor
   RECONNECT_DELAY = 5
 
-  def initialize(wallet_address, network: "mainnet")
+  def initialize(wallet_address)
     @wallet_address = wallet_address
-    @network = network
-    @ws_url = SolanaConfig.ws_url(network)
+    @ws_url = SolanaConfig.ws_url
     @running = false
   end
 
@@ -42,7 +41,7 @@ def connect_and_listen
     monitor = self
 
     ws.on :open do
-      Rails.logger.info("[SolanaWS] Connected for #{monitor.send(:@wallet_address)}")
+      Rails.logger.info("[SolanaWS] Connected for #{monitor.send(:@wallet_address)} on #{SolanaConfig.network}")
       ws.send({
         jsonrpc: "2.0",
         id: 1,
@@ -86,12 +85,10 @@ def handle_message(data)
   end
 
   def broadcast_update
-    SolanaConfig::NETWORKS.each do |net|
-      Rails.cache.delete("wallet/#{net}/#{@wallet_address}/tokens_v2")
-      Rails.cache.delete("wallet/#{net}/#{@wallet_address}/recent_txs")
-    end
+    Rails.cache.delete("wallet/#{@wallet_address}/tokens")
+    Rails.cache.delete("wallet/#{@wallet_address}/recent_txs")
 
-    portfolio = WalletPortfolioService.new(@wallet_address, network: @network)
+    portfolio = WalletPortfolioService.new(@wallet_address)
     stream = "wallet_#{@wallet_address}"
 
     Turbo::StreamsChannel.broadcast_replace_to(
@@ -106,13 +103,10 @@ def broadcast_update
       locals: { tokens: portfolio.tokens }
     )
 
-    explorer_base = @network == "mainnet" ? "https://solscan.io" : "https://explorer.solana.com"
-    explorer_cluster = @network == "mainnet" ? "" : "?cluster=#{@network}"
-
     Turbo::StreamsChannel.broadcast_replace_to(
       stream, target: "recent_activity",
       partial: "dashboard/recent_activity",
-      locals: { transactions: portfolio.recent_transactions, wallet_address: @wallet_address, explorer_base: explorer_base, explorer_cluster: explorer_cluster }
+      locals: { transactions: portfolio.recent_transactions, wallet_address: @wallet_address }
     )
   end
 end

app/models/solana_config.rb

@@ -2,28 +2,23 @@
 class TokenMetadataService
   SOL_MINT = "So11111111111111111111111111111111111111112"
 
-  def initialize(network: "mainnet", rpc_url: nil)
-    @network = network
-    @client = SolanaClient.new(rpc_url: rpc_url)
-    @mainnet = (network == "mainnet")
+  def initialize
+    @client = SolanaClient.new
   end
 
-  # Returns all tokens for a wallet with metadata and USD values.
   def token_balances_for(wallet_address)
     sol_balance = @client.get_balance(wallet_address)
     accounts = @client.get_token_accounts(wallet_address)
 
     all_mints = [ SOL_MINT ] + accounts.map { |a| a[:mint] }
 
-    # Metadata from DB (fetches from Jupiter only for new mints)
     token_records = Token.find_or_fetch_many(all_mints)
 
     # Prices only available on mainnet
-    prices = @mainnet ? JupiterClient.fetch_prices(all_mints) : {}
+    prices = SolanaConfig.mainnet? ? JupiterClient.fetch_prices(all_mints) : {}
 
     tokens = []
 
-    # SOL entry
     if sol_balance
       sol_token = token_records[SOL_MINT]
       sol_price = prices[SOL_MINT]
@@ -38,7 +33,6 @@ def token_balances_for(wallet_address)
       tokens << entry
     end
 
-    # SPL tokens
     accounts.each do |account|
       token = token_records[account[:mint]]
       price = prices[account[:mint]]