Ethereum: transaction reverted when calling swapExactETHForToken on uniswapRouter02

Ethereum transaction rolled back: Uniswap Router 0x02 SwapExactETHForToken

As an Ethereum developer, you are probably no stranger to the complexities of interacting with decentralized exchanges and smart contracts. I recently ran into a frustrating issue with the Uniswap router (0x02) while trying to swap ETH for an ERC20 token using the « swapExactETHForToken » function.

Problem: Transaction rolled back

To understand what is happening, let’s break down the scenario:

• A user pre-approves a withdrawal allowance on the Uniswap router (0x02) to spend ETH on their behalf.

• They call the swapExactETHForToken function from the smart contract, passing in the required parameters (the amount of ETH and the address of the ERC20 token).

• The transaction is sent to the Ethereum network.

However, every time this transaction occurs, the Ethereum Virtual Machine (EVM) rolls it back. This problem occurs due to a common issue known as « re-access » or « callback re-access ».

Uniswap Router Issue

In the case of the Uniswap Router (0x02), the « swapExactETHForToken » function is vulnerable to re-entry attacks. When a contract calls this function, it triggers a callback in the Uniswap Router, which can cause an infinite call loop and eventually cause the transaction to be rolled back.

Fix: Unwrapping the transaction

To fix the problem, I wrapped the call to « swapExactETHForToken » using the « unwrap » function provided by the Uniswap library. This allows us to avoid the callback and prevent the re-entry attack.

Here is an example of how you can use the « Unwrap » function:

pragma hardness ^0,8,0;
import "
contract MySwap {
SwapRouter02 public uniswapRouter;
constructor() {
uniswapRouter = new SwapRouter02();
}
function swapExactETHForToken(uint256 _amountIn, uint256[] memory _tokenA, address _to) public {
// Call the unwrap function to avoid re-entry
uniswapRouter.unwrap(_amountIn, _tokenA, _to);
}
}

By wrapping the swapExactETHForToken' call with theunwrapfunction, we ensure that the callback is not triggered and the transaction is successfully executed.

Conclusion

While the re-entry attack problem can be annoying, it is important to understand what is happening and take steps to resolve it. In this case, wrapping theswapExactETHForToken’ call using the unwrap function provides a solution to prevent re-entry attacks on the Uniswap router (0x02).

As developers, we should always be aware of these issues and take the necessary precautions to ensure the security and integrity of our smart contracts.

Additional Tips

• Always wrap transaction calls that trigger callbacks or re-entry using the Unwrap function.

• Review your smart contract implementation for potential vulnerabilities against re-entry attacks.

• Consider implementing additional protections, such as retry mechanisms or safe withdrawal quotas, to mitigate other types of issues.

METAMASK OPEN METAMASK WEBSITE