Skip to main content

​
Overview

This guide covers network configuration, available networks, and network switching with the Dynamic Swift SDK. The SDK supports both EVM chains (Ethereum, Polygon, Base, etc.) and Solana.

​
Prerequisites

​
Available Networks

​
Get Available Networks

The SDK provides access to networks enabled in your Dynamic dashboard: 
import DynamicSDKSwift

let sdk = DynamicSDK.instance()

// Get available EVM networks
let evmNetworks = sdk.networks.evm
for network in evmNetworks {
    print("EVM Network: \(network.name) (chainId: \(network.chainId.value))")
}

// Get available Solana networks
let solanaNetworks = sdk.networks.solana
for network in solanaNetworks {
    print("Solana Network: \(network.name)")
}

​
Display Networks in UI

import SwiftUI
import DynamicSDKSwift

struct NetworksListView: View {
    private let sdk = DynamicSDK.instance()
    
    var body: some View {
        List {
            Section("EVM Networks") {
                ForEach(sdk.networks.evm, id: \.name) { network in
                    HStack {
                        Text(network.name)
                        Spacer()
                        Text("Chain ID: \(String(describing: network.chainId.value))")
                            .font(.caption)
                            .foregroundColor(.secondary)
                    }
                }
            }
            
            Section("Solana Networks") {
                ForEach(sdk.networks.solana, id: \.name) { network in
                    Text(network.name)
                }
            }
        }
    }
}

​
Get Current Network

​
Get Wallet’s Current Network

import DynamicSDKSwift

let sdk = DynamicSDK.instance()

func getCurrentNetwork(wallet: BaseWallet) async {
    do {
        let network = try await sdk.wallets.getNetwork(wallet: wallet)
        print("Current network: \(network)")
    } catch {
        print("Failed to get network: \(error)")
    }
}

​
Resolve Network Name

import DynamicSDKSwift

func getNetworkDisplayName(wallet: BaseWallet) async -> String {
    let sdk = DynamicSDK.instance()
    
    do {
        let networkResult = try await sdk.wallets.getNetwork(wallet: wallet)
        let rawId = String(describing: networkResult.value.value)
        
        if wallet.chain.uppercased() == "EVM" {
            // Find matching EVM network
            if let match = sdk.networks.evm.first(where: { 
                String(describing: $0.chainId.value) == rawId 
            }) {
                return "\(match.name) (chainId: \(rawId))"
            }
            return "Chain ID: \(rawId)"
        }
        
        if wallet.chain.uppercased() == "SOL" {
            // Find matching Solana network
            if let match = sdk.networks.solana.first(where: { 
                String(describing: $0.networkId.value) == rawId 
            }) {
                return match.name
            }
            return rawId
        }
        
        return rawId
    } catch {
        return "Unknown"
    }
}

​
Switch Network

​
Switch Wallet Network

import DynamicSDKSwift

let sdk = DynamicSDK.instance()

func switchNetwork(wallet: BaseWallet, to network: GenericNetwork) async {
    do {
        try await sdk.wallets.switchNetwork(wallet: wallet, network: network)
        print("Switched to \(network.name)")
    } catch {
        print("Failed to switch network: \(error)")
    }
}

​
Complete Network Switching Example

import SwiftUI
import DynamicSDKSwift

struct SwitchNetworkView: View {
    let wallet: BaseWallet
    
    @State private var currentNetwork: String?
    @State private var isLoading = false
    @State private var errorMessage: String?
    
    private let sdk = DynamicSDK.instance()
    
    var availableNetworks: [GenericNetwork] {
        if wallet.chain.uppercased() == "EVM" {
            return sdk.networks.evm
        } else if wallet.chain.uppercased() == "SOL" {
            return sdk.networks.solana
        }
        return []
    }
    
    var body: some View {
        VStack(spacing: 16) {
            // Current network
            if let current = currentNetwork {
                Text("Current: \(current)")
                    .font(.headline)
            }
            
            // Network options
            Text("Switch to:")
                .font(.subheadline)
                .foregroundColor(.secondary)
            
            ForEach(availableNetworks, id: \.name) { network in
                Button {
                    switchToNetwork(network)
                } label: {
                    HStack {
                        Text(network.name)
                        Spacer()
                        if wallet.chain.uppercased() == "EVM" {
                            Text("Chain ID: \(String(describing: network.chainId.value))")
                                .font(.caption)
                                .foregroundColor(.secondary)
                        }
                    }
                    .padding()
                    .background(Color(.systemGray6))
                    .cornerRadius(8)
                }
                .disabled(isLoading)
            }
            
            if isLoading {
                ProgressView()
            }
            
            if let error = errorMessage {
                Text(error)
                    .foregroundColor(.red)
                    .font(.caption)
            }
        }
        .padding()
        .onAppear {
            fetchCurrentNetwork()
        }
    }
    
    private func fetchCurrentNetwork() {
        Task { @MainActor in
            do {
                let network = try await sdk.wallets.getNetwork(wallet: wallet)
                let rawId = String(describing: network.value.value)
                
                if wallet.chain.uppercased() == "EVM" {
                    if let match = sdk.networks.evm.first(where: { 
                        String(describing: $0.chainId.value) == rawId 
                    }) {
                        currentNetwork = match.name
                    } else {
                        currentNetwork = "Chain ID: \(rawId)"
                    }
                } else {
                    currentNetwork = rawId
                }
            } catch {
                print("Failed to get current network: \(error)")
            }
        }
    }
    
    private func switchToNetwork(_ network: GenericNetwork) {
        isLoading = true
        errorMessage = nil
        
        Task { @MainActor in
            do {
                try await sdk.wallets.switchNetwork(wallet: wallet, network: network)
                currentNetwork = network.name
            } catch {
                errorMessage = "Failed to switch: \(error.localizedDescription)"
            }
            isLoading = false
        }
    }
}

​
Network-Specific Operations

​
EVM Networks

For EVM operations, you can create a public client for specific chains: 
import DynamicSDKSwift

let sdk = DynamicSDK.instance()

func getGasPrice(chainId: Int) async {
    do {
        let client = try await sdk.evm.createPublicClient(chainId: chainId)
        let gasPrice = try await client.getGasPrice()
        print("Gas price: \(gasPrice.value)")
    } catch {
        print("Failed to get gas price: \(error)")
    }
}

​
Solana Networks

For Solana operations, create a connection: 
import DynamicSDKSwift

let sdk = DynamicSDK.instance()

func getSolanaConnection() async {
    do {
        let connection = try await sdk.solana.createConnection()
        let blockhash = try await connection.getLatestBlockhash()
        print("Latest blockhash: \(blockhash)")
    } catch {
        print("Failed to get Solana connection: \(error)")
    }
}

​
Best Practices

​
1. Check Network Before Operations

func sendTransaction(wallet: BaseWallet) async {
    // Get current network first
    let currentNetwork = try? await sdk.wallets.getNetwork(wallet: wallet)
    
    // Verify it's the expected network
    // Then proceed with transaction
}

​
2. Handle Network Switching Errors

do {
    try await sdk.wallets.switchNetwork(wallet: wallet, network: targetNetwork)
} catch {
    // Network switching can fail if:
    // - Network is not supported
    // - User cancels the switch
    // - Network connection issues
    showError("Could not switch network. Please try again.")
}

​
3. Display Network Information Clearly

struct NetworkBadge: View {
    let network: GenericNetwork
    let chain: String
    
    var body: some View {
        HStack {
            Text(network.name)
                .font(.caption)
            if chain.uppercased() == "EVM" {
                Text("(\(String(describing: network.chainId.value)))")
                    .font(.caption2)
                    .foregroundColor(.secondary)
            }
        }
        .padding(.horizontal, 8)
        .padding(.vertical, 4)
        .background(Color.blue.opacity(0.2))
        .cornerRadius(4)
    }
}

​
Error Handling

do {
    try await sdk.wallets.switchNetwork(wallet: wallet, network: network)
} catch {
    // Handle specific error cases
    let errorMessage: String
    
    if error.localizedDescription.contains("not supported") {
        errorMessage = "This network is not supported"
    } else if error.localizedDescription.contains("connection") {
        errorMessage = "Network connection failed"
    } else {
        errorMessage = "Failed to switch network"
    }
    
    showAlert(errorMessage)
}

​
Next Steps

After mastering network management, you can: