Swift

import Web3
import BigInt
 
class EthereumClient {
    private let web3 = Web3(rpcURL: "https://avalanche.therpc.io/YOUR_API_KEY")
 
    func getBalance(address: String) async throws -> Double {
        let address = try EthereumAddress(hex: address, eip55: true)
        let balance = try await web3.eth.getBalance(address: address)
        return balance.converted(to: .ether).value
    }
 
    func sendTransaction(
        from: EthereumPrivateKey,
        to: String,
        amount: Double
    ) async throws -> String {
        let toAddress = try EthereumAddress(hex: to, eip55: true)
        let amount = EthereumAmount(value: amount, unit: .ether)
 
        let transaction = try await web3.eth.prepareTransaction(
            to: toAddress,
            value: amount,
            from: from.address
        )
 
        let signed = try transaction.sign(with: from)
        return try await web3.eth.send(transaction: signed)
    }
}

import SwiftUI
import Web3
 
struct WalletView: View {
    @StateObject private var viewModel = WalletViewModel()
 
    var body: some View {
        VStack {
            Text("Balance: \(viewModel.balance) AVAX")
 
            Button("Refresh") {
                Task {
                    await viewModel.updateBalance()
                }
            }
        }
    }
}
 
class WalletViewModel: ObservableObject {
    private let client = EthereumClient()
    @Published var balance: Double = 0
 
    func updateBalance() async {
        do {
            balance = try await client.getBalance(address: "YOUR_ADDRESS")
        } catch {
            print("Error: \(error)")
        }
    }
}

struct Contract {
    let web3 = Web3(rpcURL: "https://avalanche.therpc.io/YOUR_API_KEY")
    let contractAddress: EthereumAddress
 
    func callMethod() async throws -> String {
        let contract = try await web3.eth.Contract(
            json: contractABI,
            address: contractAddress
        )
 
        return try await contract.method(
            "methodName",
            parameters: [param1, param2],
            extraData: Data()
        ).call()
    }
}

enum EthereumError: Error {
    case invalidAddress
    case insufficientFunds
    case networkError(String)
}
 
extension EthereumClient {
    func safeGetBalance(address: String) async throws -> Double {
        guard address.hasPrefix("0x") else {
            throw EthereumError.invalidAddress
        }
 
        do {
            return try await getBalance(address: address)
        } catch {
            throw EthereumError.networkError(error.localizedDescription)
        }
    }
}