The process of converting ETH to USD within smart contracts can seem complex, especially when dealing with blockchain-specific units like wei and price feeds scaled by factors such as 1e8. This article breaks down the core logic behind ETH-to-USD conversion in Solidity, using a practical example that leverages Chainlink's price oracle. Whether you're building a crowdfunding platform or any decentralized application involving fiat-pegged values, understanding this conversion is crucial.
We'll walk through the key components of a real-world contract, explain why certain calculations are structured the way they are, and clarify common points of confusion—especially around unit scaling and precision handling.
How Ethereum Handles Value: Wei and Ether
In Ethereum, all value transfers are denominated in wei, the smallest unit of ETH (1 ETH = 10¹⁸ wei). When users send ETH to a contract via msg.value, the amount is automatically expressed in wei. However, for user-facing logic—like setting minimum funding thresholds in USD—we need to convert this raw wei value into a human-readable dollar equivalent.
This is where external data comes in: price oracles.
Integrating Chainlink Price Feeds
To get the current market price of ETH in USD, the contract uses Chainlink's AggregatorV3Interface, a trusted decentralized oracle network. The constructor initializes the data feed using a specific address for the Sepolia testnet:
dataFeed = AggregatorV3Interface(0x694AA1769357215DE4FAC081bf1f309aDC325306);Chainlink returns prices with high precision. For example, if ETH is trading at $3,500.50, the oracle might return 350050000000, which represents $3,500.50 × 10⁸ (i.e., 8 decimal places). This scaling ensures no loss of precision in integer-only environments like the EVM.
👉 Discover how blockchain oracles power real-world data in DeFi applications.
Converting wei to USD: The Core Formula
The function convertEthToUsd(uint256 ethAmount) performs the critical conversion from wei to USD:
function convertEthToUsd(uint256 ethAmount) internal view returns(uint256){
uint256 ethPrice = uint256(getChainLinkDataFeedLatestAnswer());
return ethAmount * ethPrice / (10 ** 8);
}Let’s break it down:
ethAmount: Amount of ETH sent, in weiethPrice: Current ETH/USD price from Chainlink, scaled by 1e8- Result:
(wei * price_per_eth_in_usd_with_8_decimals) / 1e8
Since ethAmount is already in wei (1e18 smaller than ETH), multiplying it directly by the Chainlink price gives a result that's effectively scaled by 1e18 × 1e8 = 1e26. Dividing by 1e8 normalizes it back so the output reflects the USD value in wei terms—allowing consistent comparison across large numbers without floating-point math.
Why Use 100 * 10**18 for Minimum Value?
You may wonder why the minimum threshold is defined as:
uint256 MININUM_VALUE = 100 * 10 ** 18; // USD in wei-equivalentThis is because the result of convertEthToUsd() returns an amount that represents how many wei would equal that USD value, not a simple integer like 100. So when comparing money >= MININUM_VALUE, both sides must be in the same unit—wei-scaled USD.
For example:
- If a user sends 0.1 ETH and ETH price is $3,500
- That’s 0.1 × 3,500 = $350 worth of ETH
- But internally, this $350 is represented as 350 × 1e18 (to match wei scaling)
- Hence, comparing against
100 * 1e18means “is this at least $100?”
This design maintains precision and avoids type casting issues in Solidity.
Alternative Approach: Convert Back to Whole Numbers
As noted in the original code, you could instead divide the result to get a plain USD number:
uint256 convertRealMoney = money / (10 ** 18);
require(convertRealMoney >= 100, "send more ETH");While this improves readability, it risks truncation if intermediate values aren't carefully managed. Staying in wei-scale throughout avoids fractional losses and aligns with standard DeFi practices.
👉 Learn how precise unit handling enhances security in smart contracts.
Funding and Withdrawal Logic
The contract implements basic crowdfunding rules:
- Investors call
fund()with sufficient ETH (≥ $100 equivalent) - Their contribution is recorded in
fundersToAmount - Producers can later call
getFund()to withdraw funds only if the total raised meets or exceeds the target (TARGET = 1000 * 1e18, i.e., $1,000)
This ensures conditional execution based on financial goals—common in project funding dApps.
Key Smart Contract Best Practices Illustrated
Several best practices emerge from this example:
- Use constants for fixed values like targets and minimums
- Leverage events (
EthToUsdEvent,MoneySumEvent) for off-chain monitoring - Keep conversions internal and reusable
- Validate inputs early with
requirestatements - Rely on trusted oracles for external data
These principles enhance security, maintainability, and transparency.
👉 Explore secure coding patterns used in production-grade DeFi protocols.
Frequently Asked Questions
Q: Why does Chainlink return prices multiplied by 1e8?
A: Solidity doesn’t support floating-point numbers. Multiplying by 1e8 allows representing up to 8 decimal places using integers, preserving accuracy without rounding errors.
Q: Can I use this contract on mainnet?
A: Yes, but you must update the oracle address to the correct one for Ethereum mainnet (e.g., ETH/USD feed at 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419).
Q: What happens if the price feed fails?
A: Always wrap oracle calls in try-catch blocks or use timeouts in production. Relying on stale or unavailable data can freeze contract functionality.
Q: Is dividing by 1e8 safe from overflow?
A: With very large ethAmount values, multiplication before division could cause overflow. Consider using SafeMath or OpenZeppelin’s SafeCast libraries for added protection.
Q: Why not work in ETH instead of USD?
A: USD-denominated thresholds provide stable valuation regardless of ETH’s volatility—essential for predictable business logic in fundraising or payments.
Q: How do I test this locally?
A: Use Hardhat or Foundry with mock Chainlink contracts. Deploy mocks that return fixed prices to simulate different market conditions during testing.
Conclusion
Understanding how to accurately convert ETH to USD in smart contracts is fundamental for building reliable DeFi applications. By respecting unit scaling—especially between wei, ether, and oracle-fed prices—you ensure your logic behaves as expected under real-world conditions.
The pattern shown here—using Chainlink oracles, converting values with proper scaling, and enforcing conditions based on fiat equivalents—is widely used across decentralized finance platforms. Mastering it empowers developers to create robust, secure, and user-friendly blockchain solutions.