Swift工具

import Web3
import BigInt

class EthereumClient {
    private let web3 = Web3(rpcURL: "YOUR_ETHEREUM_NODE_URL")

    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) ETH")

            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: "YOUR_ETHEREUM_NODE_URL")
    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)
        }
    }
}