let networkClient = try await ethereumWallet.getNetworkClient(for: chainId)
do {
let gasPrice = try await networkClient.eth_gasPriceBigInt()
print("Current gas price: \(gasPrice) wei")
} catch {
print("Failed to get gas price: \(error)")
}
// Standard gas limit for ETH transfers (used in sample app)
let gasLimit = BigUInt(21_000) // Standard ETH transfer
print("ETH Transfer Gas Limit: \(gasLimit)")
let dynamicClient: DynamicClient
let ethereumWallet: EthereumWallet
let chainId = SupportedEthereumNetwork.sepoliaTestnet.chainConfig.chainId
do {
let networkClient = try await ethereumWallet.getNetworkClient(for: chainId)
print("Connected to Sepolia network: \(chainId)")
// Get gas price for transactions
let gasPrice = try await networkClient.eth_gasPriceBigInt()
print("Current gas price: \(gasPrice) wei")
} catch {
print("Failed to get network client: \(error)")
}
// Convert Wei to Gwei for user-friendly display
func weiToGwei(_ wei: BigUInt) -> Double {
let gweiValue = Double(String(wei)) ?? 0.0
return gweiValue / pow(10.0, 9.0) // 1 Gwei = 10^9 Wei
}
// Usage
let gasPriceWei = try await networkClient.eth_gasPriceBigInt()
let gasPriceGwei = weiToGwei(gasPriceWei)
print("Gas Price: \(String(format: "%.2f", gasPriceGwei)) Gwei")
// Common gas limits for different transaction types
struct GasLimits {
static let ethTransfer = BigUInt(21_000) // Standard ETH transfer
static let erc20Transfer = BigUInt(65_000) // ERC-20 token transfer
static let contractDeploy = BigUInt(500_000) // Contract deployment
static let contractCall = BigUInt(100_000) // Contract function call
}
// Usage
let gasLimit = GasLimits.ethTransfer
print("Using standard ETH transfer gas limit: \(gasLimit)")
// Estimate gas for complex transactions
func estimateGasForTransaction(_ transaction: EthereumTransaction) async throws -> BigUInt {
let networkClient = try await ethereumWallet.getNetworkClient(for: transaction.chainId)
return try await networkClient.eth_estimateGas(transaction)
}
// Usage
let transaction = EthereumTransaction(
from: ethereumWallet.address,
to: recipient,
value: amount,
data: Data(),
nonce: nil,
gasPrice: gasPrice,
gasLimit: nil, // Will be estimated
chainId: chainId
)
do {
let estimatedGas = try await estimateGasForTransaction(transaction)
print("Estimated gas: \(estimatedGas)")
// Add buffer for safety (20% buffer)
let gasWithBuffer = estimatedGas + (estimatedGas / 5)
print("Gas with buffer: \(gasWithBuffer)")
} catch {
print("Failed to estimate gas: \(error)")
}
// Get optimal gas price based on network conditions
func getOptimalGasPrice() async throws -> BigUInt {
let networkClient = try await ethereumWallet.getNetworkClient(for: chainId)
let currentGasPrice = try await networkClient.eth_gasPriceBigInt()
// Add 10% buffer for faster confirmation
let optimalGasPrice = currentGasPrice + (currentGasPrice / 10)
return optimalGasPrice
}
// Usage
do {
let optimalGasPrice = try await getOptimalGasPrice()
print("Optimal gas price: \(optimalGasPrice) wei")
} catch {
print("Failed to get optimal gas price: \(error)")
}
enum GasStrategy {
case low // Slow but cheap
case medium // Balanced
case high // Fast but expensive
}
func getGasPriceForStrategy(_ strategy: GasStrategy, basePrice: BigUInt) -> BigUInt {
switch strategy {
case .low:
return basePrice - (basePrice / 10) // 10% below base
case .medium:
return basePrice // Use base price
case .high:
return basePrice + (basePrice / 5) // 20% above base
}
}
// Usage
let baseGasPrice = try await networkClient.eth_gasPriceBigInt()
let fastGasPrice = getGasPriceForStrategy(.high, basePrice: baseGasPrice)
print("Fast gas price: \(fastGasPrice) wei")
let fromAddress = ethereumWallet.address
let toAddress = EthereumAddress("0xRecipientAddress")
let amount = BigUInt(1000000000000000000) // 1 ETH in wei
let gasPrice = try await networkClient.eth_gasPriceBigInt()
let gasLimit = BigUInt(21_000)
let chainId = SupportedEthereumNetwork.sepoliaTestnet.chainConfig.chainId
let transaction = EthereumTransaction(
from: fromAddress,
to: toAddress,
value: amount,
data: Data(),
nonce: nil,
gasPrice: gasPrice,
gasLimit: gasLimit,
chainId: chainId
)
// Calculate total transaction cost in ETH
func calculateTransactionCost(gasPrice: BigUInt, gasLimit: BigUInt) -> Double {
let totalWei = gasPrice * gasLimit
let totalEth = Double(String(totalWei)) ?? 0.0
return totalEth / pow(10.0, 18.0)
}
// Usage
let gasPrice = try await networkClient.eth_gasPriceBigInt()
let gasLimit = BigUInt(21_000)
let cost = calculateTransactionCost(gasPrice: gasPrice, gasLimit: gasLimit)
print("Transaction cost: \(String(format: "%.6f", cost)) ETH")
// Always get current gas price before sending transactions
let gasPrice = try await networkClient.eth_gasPriceBigInt()
let gasLimit = BigUInt(21_000) // Standard ETH transfer
// For complex transactions, estimate gas limit
let estimatedGas = try await networkClient.eth_estimateGas(transaction)
// Use standard limits for simple transactions
let gasLimit = GasLimits.ethTransfer
// Estimate for complex transactions
let estimatedGas = try await estimateGasForTransaction(transaction)
let gasWithBuffer = estimatedGas + (estimatedGas / 5) // 20% buffer
// Monitor gas prices for optimal timing
func monitorGasPrices() async {
while true {
do {
let gasPrice = try await networkClient.eth_gasPriceBigInt()
let gasPriceGwei = weiToGwei(gasPrice)
print("Current gas price: \(String(format: "%.2f", gasPriceGwei)) Gwei")
// Wait 30 seconds before next check
try await Task.sleep(nanoseconds: 30_000_000_000)
} catch {
print("Failed to get gas price: \(error)")
break
}
}
}
do {
let gasPrice = try await networkClient.eth_gasPriceBigInt()
} catch {
if let nsError = error as NSError? {
switch nsError.code {
case 5001:
print("Gas price too high")
case 5002:
print("Gas limit exceeded")
case 5003:
print("Insufficient gas for transaction")
default:
print("Gas error: \(error)")
}
}
}
Was this page helpful?