// SPDX-License-Identifier: MIT
pragma solidity ^0.8;
interface WETH10 {
function flashLoan(
address receiver,
address token,
uint value,
bytes calldata data
) external returns (bool);
}
interface IERC20 {
/**
* @dev Returns the amount of tokens in existence.
*/
function totalSupply() external view returns (uint256);
/**
* @dev Returns the amount of tokens owned by `account`.
*/
function balanceOf(address account) external view returns (uint256);
/**
* @dev Moves `amount` tokens from the caller's account to `recipient`.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transfer(address recipient, uint256 amount) external returns (bool);
/**
* @dev Returns the remaining number of tokens that `spender` will be
* allowed to spend on behalf of `owner` through {transferFrom}. This is
* zero by default.
*
* This value changes when {approve} or {transferFrom} are called.
*/
function allowance(address owner, address spender) external view returns (uint256);
/**
* @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* IMPORTANT: Beware that changing an allowance with this method brings the risk
* that someone may use both the old and the new allowance by unfortunate
* transaction ordering. One possible solution to mitigate this race
* condition is to first reduce the spender's allowance to 0 and set the
* desired value afterwards:
* https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
*
* Emits an {Approval} event.
*/
function approve(address spender, uint256 amount) external returns (bool);
/**
* @dev Moves `amount` tokens from `sender` to `recipient` using the
* allowance mechanism. `amount` is then deducted from the caller's
* allowance.
*
* Returns a boolean value indicating whether the operation succeeded.
*
* Emits a {Transfer} event.
*/
function transferFrom(
address sender,
address recipient,
uint256 amount
) external returns (bool);
/**
* @dev Emitted when `value` tokens are moved from one account (`from`) to
* another (`to`).
*
* Note that `value` may be zero.
*/
event Transfer(address indexed from, address indexed to, uint256 value);
/**
* @dev Emitted when the allowance of a `spender` for an `owner` is set by
* a call to {approve}. `value` is the new allowance.
*/
event Approval(address indexed owner, address indexed spender, uint256 value);
}
contract TestWethFlashMint {
// WETH 10
address private WETH = 0xf4BB2e28688e89fCcE3c0580D37d36A7672E8A9F;
bytes32 public immutable CALLBACK_SUCCESS =
keccak256("ERC3156FlashBorrower.onFlashLoan");
address public sender;
address public token;
event Log(string name, uint val);
function flash() external {
uint total = IERC20(WETH).totalSupply();
// borrow more than available
uint amount = total + 1;
emit Log("total supply", total);
IERC20(WETH).approve(WETH, amount);
bytes memory data = "";
WETH10(WETH).flashLoan(address(this), WETH, amount, data);
}
// called by WETH10
function onFlashLoan(
address _sender,
address _token,
uint amount,
uint fee,
bytes calldata data
) external returns (bytes32) {
uint bal = IERC20(WETH).balanceOf(address(this));
sender = _sender;
token = _token;
emit Log("amount", amount);
emit Log("fee", fee);
emit Log("balance", bal);
return CALLBACK_SUCCESS;
}
}