Description:
Proxy contract enabling upgradeable smart contract patterns. Delegates calls to an implementation contract.
Blockchain: Ethereum
Source Code: View Code On The Blockchain
Solidity Source Code:
{{
"language": "Solidity",
"sources": {
"src/Auctions/AuctionFactory.sol": {
"content": "// SPDX-License-Identifier: AGPL-3.0
pragma solidity >=0.8.18;
import {Auction} from "./Auction.sol";
import {ClonableCreate2} from "../utils/ClonableCreate2.sol";
/// @title AuctionFactory (Curious Cow Edition)
/// @notice Deploy a new Auction with the ability to let Cowswap settle at the next price.
contract AuctionFactory is ClonableCreate2 {
event DeployedNewAuction(address indexed auction, address indexed want);
/// @notice The amount to start the auction with.
uint256 public constant DEFAULT_STARTING_PRICE = 1_000_000;
/// @notice Full array of all auctions deployed through this factory.
address[] public auctions;
constructor() {
// Deploy the original
original = address(new Auction());
}
function version() external pure returns (string memory) {
return "1.0.3cc";
}
/**
* @notice Creates a new auction contract.
* @param _want Address of the token users will bid with.
* @return _newAuction Address of the newly created auction contract.
*/
function createNewAuction(address _want) external returns (address) {
return
_createNewAuction(
_want,
msg.sender,
msg.sender,
DEFAULT_STARTING_PRICE,
bytes32(0)
);
}
/**
* @notice Creates a new auction contract.
* @param _want Address of the token users will bid with.
* @param _receiver Address that will receive the funds in the auction.
* @return _newAuction Address of the newly created auction contract.
*/
function createNewAuction(
address _want,
address _receiver
) external returns (address) {
return
_createNewAuction(
_want,
_receiver,
msg.sender,
DEFAULT_STARTING_PRICE,
bytes32(0)
);
}
/**
* @notice Creates a new auction contract.
* @param _want Address of the token users will bid with.
* @param _receiver Address that will receive the funds in the auction.
* @param _governance Address allowed to enable and disable auctions.
* @return _newAuction Address of the newly created auction contract.
*/
function createNewAuction(
address _want,
address _receiver,
address _governance
) external returns (address) {
return
_createNewAuction(
_want,
_receiver,
_governance,
DEFAULT_STARTING_PRICE,
bytes32(0)
);
}
/**
* @notice Creates a new auction contract.
* @param _want Address of the token users will bid with.
* @param _receiver Address that will receive the funds in the auction.
* @param _governance Address allowed to enable and disable auctions.
* @param _startingPrice Starting price for the auction (no decimals).
* NOTE: The starting price should be without decimals (1k == 1_000).
* @return _newAuction Address of the newly created auction contract.
*/
function createNewAuction(
address _want,
address _receiver,
address _governance,
uint256 _startingPrice
) external returns (address) {
return
_createNewAuction(
_want,
_receiver,
_governance,
_startingPrice,
bytes32(0)
);
}
/**
* @notice Creates a new auction contract.
* @param _want Address of the token users will bid with.
* @param _receiver Address that will receive the funds in the auction.
* @param _governance Address allowed to enable and disable auctions.
* @param _startingPrice Starting price for the auction (no decimals).
* @param _salt The salt to use for deterministic deployment.
* @return _newAuction Address of the newly created auction contract.
*/
function createNewAuction(
address _want,
address _receiver,
address _governance,
uint256 _startingPrice,
bytes32 _salt
) external returns (address) {
return
_createNewAuction(
_want,
_receiver,
_governance,
_startingPrice,
_salt
);
}
/**
* @dev Deploys and initializes a new Auction
*/
function _createNewAuction(
address _want,
address _receiver,
address _governance,
uint256 _startingPrice,
bytes32 _salt
) internal returns (address _newAuction) {
if (_salt == bytes32(0)) {
// If none set, generate unique salt. msg.sender gets encoded in getSalt()
_salt = keccak256(abi.encodePacked(_want, _receiver, _governance));
}
_newAuction = _cloneCreate2(_salt);
Auction(_newAuction).initialize(
_want,
_receiver,
_governance,
_startingPrice
);
auctions.push(_newAuction);
emit DeployedNewAuction(_newAuction, _want);
}
/**
* @notice Get the full list of auctions deployed through this factory.
*/
function getAllAuctions() external view returns (address[] memory) {
return auctions;
}
/**
* @notice Get the total number of auctions deployed through this factory.
*/
function numberOfAuctions() external view returns (uint256) {
return auctions.length;
}
}
"
},
"src/Auctions/Auction.sol": {
"content": "// SPDX-License-Identifier: AGPL-3.0
pragma solidity >=0.8.18;
import {Maths} from "../libraries/Maths.sol";
import {ITaker} from "../interfaces/ITaker.sol";
import {GPv2Order} from "../libraries/GPv2Order.sol";
import {Governance2Step} from "../utils/Governance2Step.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/security/ReentrancyGuard.sol";
interface ICowSettlement {
function domainSeparator() external view returns (bytes32);
}
/**
* @title Auction (Curious Cow edition)
* @author yearn.fi
* @notice General use dutch auction contract for token sales, with the option to allow Cowswap solvers to take
* based on the upcoming price instead of the current one.
*/
contract Auction is Governance2Step, ReentrancyGuard {
using GPv2Order for GPv2Order.Data;
using SafeERC20 for ERC20;
/// @notice Emitted when a new auction is enabled
event AuctionEnabled(address indexed from, address indexed to);
/// @notice Emitted when an auction is disabled.
event AuctionDisabled(address indexed from, address indexed to);
/// @notice Emitted when auction has been kicked.
event AuctionKicked(address indexed from, uint256 available);
/// @notice Emitted when the starting price is updated.
event UpdatedStartingPrice(uint256 startingPrice);
/// @notice Emitted when the step decay rate is updated.
event UpdatedStepDecayRate(uint256 indexed stepDecayRate);
/// @notice Emitted when the step duration is updated.
event UpdatedStepDuration(uint256 indexed stepDuration);
/// @notice Emitted when we update whether COW can use the next price or not.
event UpdatedLetCowPeek(bool letCowPeek);
/// @notice Emitted when the auction is settled.
event AuctionSettled(address indexed from);
/// @notice Emitted when the auction is swept.
event AuctionSwept(address indexed token, address indexed to);
/// @dev Store address and scaler in one slot.
struct TokenInfo {
address tokenAddress;
uint96 scaler;
}
/// @notice Store all the auction specific information.
struct AuctionInfo {
uint64 kicked;
uint64 scaler;
uint128 initialAvailable;
}
uint256 internal constant WAD = 1e18;
address internal constant COW_SETTLEMENT =
0x9008D19f58AAbD9eD0D60971565AA8510560ab41;
address internal constant VAULT_RELAYER =
0xC92E8bdf79f0507f65a392b0ab4667716BFE0110;
/// @notice The time that each auction lasts.
uint256 internal constant AUCTION_LENGTH = 1 days;
/// @notice Struct to hold the info for `want`.
TokenInfo internal wantInfo;
/// @notice The address that will receive the funds in the auction.
address public receiver;
/// @notice The amount to start the auction at.
/// @dev This is an unscaled "lot size" essentially to start the pricing in "want".
/// The kicked amount of _from is divided by this to get the per auction initial price.
uint256 public startingPrice;
/// @notice The time period for each price step in seconds.
uint256 public stepDuration;
/// @notice The decay rate per step in basis points (e.g., 50 for 0.5% decrease per step).
uint256 public stepDecayRate;
/// @notice Mapping from `from` token to its struct.
mapping(address => AuctionInfo) public auctions;
/// @notice Array of all the enabled auction for this contract.
address[] public enabledAuctions;
/// @notice Whether we allow cow solvers to submit solutions based on the next price.
bool public letCowPeek;
constructor() Governance2Step(msg.sender) {}
/**
* @notice Initializes the Auction contract with initial parameters.
* @param _want Address this auction is selling to.
* @param _receiver Address that will receive the funds from the auction.
* @param _governance Address of the contract governance.
* @param _startingPrice Starting price for each auction.
*/
function initialize(
address _want,
address _receiver,
address _governance,
uint256 _startingPrice
) public virtual {
require(stepDecayRate == 0, "initialized");
require(_want != address(0), "ZERO ADDRESS");
require(_startingPrice != 0, "starting price");
require(_receiver != address(0), "receiver");
// Cannot have more than 18 decimals.
uint256 decimals = ERC20(_want).decimals();
require(decimals <= 18, "unsupported decimals");
// Set variables
wantInfo = TokenInfo({
tokenAddress: _want,
scaler: uint96(WAD / 10 ** decimals)
});
receiver = _receiver;
governance = _governance;
emit GovernanceTransferred(address(0), _governance);
startingPrice = _startingPrice;
emit UpdatedStartingPrice(_startingPrice);
// Default to 50bps every 60 seconds
stepDuration = 60;
emit UpdatedStepDuration(stepDuration);
stepDecayRate = 50; // 50 basis points = 0.5% decay per step
emit UpdatedStepDecayRate(stepDecayRate);
}
/*//////////////////////////////////////////////////////////////
VIEW METHODS
//////////////////////////////////////////////////////////////*/
function version() external pure returns (string memory) {
return "1.0.3cc";
}
/**
* @notice Get the address of this auctions want token.
* @return . The want token.
*/
function want() public view virtual returns (address) {
return wantInfo.tokenAddress;
}
function auctionLength() public view virtual returns (uint256) {
return AUCTION_LENGTH;
}
/**
* @notice Get the available amount for the auction.
* @param _from The address of the token to be auctioned.
* @return . The available amount for the auction.
*/
function available(address _from) public view virtual returns (uint256) {
if (!isActive(_from)) return 0;
return
Maths.min(
auctions[_from].initialAvailable,
ERC20(_from).balanceOf(address(this))
);
}
/**
* @notice Get the kicked timestamp for the auction.
* @param _from The address of the token to be auctioned.
* @return . The kicked timestamp for the auction.
*/
function kicked(address _from) external view virtual returns (uint256) {
return auctions[_from].kicked;
}
/**
* @notice Check if the auction is active.
* @param _from The address of the token to be auctioned.
* @return . Whether the auction is active.
*/
function isActive(address _from) public view virtual returns (bool) {
return auctions[_from].kicked + AUCTION_LENGTH >= block.timestamp;
}
/**
* @notice Get all the enabled auctions.
*/
function getAllEnabledAuctions()
external
view
virtual
returns (address[] memory)
{
return enabledAuctions;
}
/**
* @notice Get the pending amount available for the next auction.
* @dev Defaults to the auctions balance of the from token if no hook.
* @param _from The address of the token to be auctioned.
* @return uint256 The amount that can be kicked into the auction.
*/
function kickable(address _from) external view virtual returns (uint256) {
// If not enough time has passed then `kickable` is 0.
if (isActive(_from)) return 0;
// Use the full balance of this contract.
return ERC20(_from).balanceOf(address(this));
}
/**
* @notice Gets the amount of `want` needed to buy the available amount of `from`.
* @param _from The address of the token to be auctioned.
* @return . The amount of `want` needed to fulfill the take amount.
*/
function getAmountNeeded(
address _from
) external view virtual returns (uint256) {
return
_getAmountNeeded(
auctions[_from],
available(_from),
block.timestamp
);
}
/**
* @notice Gets the amount of `want` needed to buy a specific amount of `from`.
* @param _from The address of the token to be auctioned.
* @param _amountToTake The amount of `from` to take in the auction.
* @return . The amount of `want` needed to fulfill the take amount.
*/
function getAmountNeeded(
address _from,
uint256 _amountToTake
) external view virtual returns (uint256) {
return
_getAmountNeeded(auctions[_from], _amountToTake, block.timestamp);
}
/**
* @notice Gets the amount of `want` needed to buy a specific amount of `from` at a specific timestamp.
* @param _from The address of the token to be auctioned.
* @param _amountToTake The amount `from` to take in the auction.
* @param _timestamp The specific timestamp for calculating the amount needed.
* @return . The amount of `want` needed to fulfill the take amount.
*/
function getAmountNeeded(
address _from,
uint256 _amountToTake,
uint256 _timestamp
) external view virtual returns (uint256) {
return _getAmountNeeded(auctions[_from], _amountToTake, _timestamp);
}
/**
* @dev Return the amount of `want` needed to buy `_amountToTake`.
*/
function _getAmountNeeded(
AuctionInfo memory _auction,
uint256 _amountToTake,
uint256 _timestamp
) internal view virtual returns (uint256) {
return
// Scale _amountToTake to 1e18
(_amountToTake *
_auction.scaler *
// Price is always 1e18
_price(
_auction.kicked,
_auction.initialAvailable * _auction.scaler,
_timestamp
)) /
1e18 /
// Scale back down to want.
wantInfo.scaler;
}
/**
* @notice Gets the price of the auction at the current timestamp.
* @param _from The address of the token to be auctioned.
* @return . The price of the auction.
*/
function price(address _from) external view virtual returns (uint256) {
return price(_from, block.timestamp);
}
/**
* @notice Gets the price of the auction at a specific timestamp.
* @param _from The address of the token to be auctioned.
* @param _timestamp The specific timestamp for calculating the price.
* @return . The price of the auction.
*/
function price(
address _from,
uint256 _timestamp
) public view virtual returns (uint256) {
// Get unscaled price and scale it down.
return
_price(
auctions[_from].kicked,
auctions[_from].initialAvailable * auctions[_from].scaler,
_timestamp
) / wantInfo.scaler;
}
/**
* @dev Internal function to calculate the scaled price based on auction parameters.
* @param _kicked The timestamp the auction was kicked.
* @param _available The initial available amount scaled 1e18.
* @param _timestamp The specific timestamp for calculating the price.
* @return . The calculated price scaled to 1e18.
*/
function _price(
uint256 _kicked,
uint256 _available,
uint256 _timestamp
) internal view virtual returns (uint256) {
if (_available == 0) return 0;
uint256 secondsElapsed = _timestamp - _kicked;
if (secondsElapsed > AUCTION_LENGTH) return 0;
// Calculate the number of price steps that have passed
uint256 steps = secondsElapsed / stepDuration;
// Convert basis points to ray multiplier (e.g., 50 bps = 0.995 * 1e27)
// rayMultiplier = 1e27 - (basisPoints * 1e23)
uint256 rayMultiplier = 1e27 - (stepDecayRate * 1e23);
// Calculate the decay multiplier using the configurable decay rate per step
uint256 decayMultiplier = Maths.rpow(rayMultiplier, steps);
// Calculate initial price per token
uint256 initialPrice = Maths.wdiv(startingPrice * 1e18, _available);
// Apply the decay to get the current price
return Maths.rmul(initialPrice, decayMultiplier);
}
/*//////////////////////////////////////////////////////////////
SETTERS
//////////////////////////////////////////////////////////////*/
/**
* @notice Enables a new auction.
* @param _from The address of the token to be auctioned.
*/
function enable(address _from) external virtual onlyGovernance {
address _want = want();
require(_from != address(0) && _from != _want, "ZERO ADDRESS");
require(auctions[_from].scaler == 0, "already enabled");
// Cannot have more than 18 decimals.
uint256 decimals = ERC20(_from).decimals();
require(decimals <= 18, "unsupported decimals");
// Store all needed info.
auctions[_from].scaler = uint64(WAD / 10 ** decimals);
ERC20(_from).forceApprove(VAULT_RELAYER, type(uint256).max);
// Add to the array.
enabledAuctions.push(_from);
emit AuctionEnabled(_from, _want);
}
/**
* @notice Disables an existing auction.
* @dev Only callable by governance.
* @param _from The address of the token being sold.
*/
function disable(address _from) external virtual {
disable(_from, 0);
}
/**
* @notice Disables an existing auction.
* @dev Only callable by governance.
* @param _from The address of the token being sold.
* @param _index The index the auctionId is at in the array.
*/
function disable(
address _from,
uint256 _index
) public virtual onlyGovernance {
// Make sure the auction was enabled.
require(auctions[_from].scaler != 0, "not enabled");
// Remove the struct.
delete auctions[_from];
ERC20(_from).forceApprove(VAULT_RELAYER, 0);
// Remove the auction ID from the array.
address[] memory _enabledAuctions = enabledAuctions;
if (_enabledAuctions[_index] != _from) {
// If the _index given is not the id find it.
for (uint256 i = 0; i < _enabledAuctions.length; ++i) {
if (_enabledAuctions[i] == _from) {
_index = i;
break;
}
}
}
// Move the id to the last spot if not there.
if (_index < _enabledAuctions.length - 1) {
_enabledAuctions[_index] = _enabledAuctions[
_enabledAuctions.length - 1
];
// Update the array.
enabledAuctions = _enabledAuctions;
}
// Pop the id off the array.
enabledAuctions.pop();
emit AuctionDisabled(_from, want());
}
function isAnActiveAuction() public view returns (bool) {
address[] memory _enabledAuctions = enabledAuctions;
for (uint256 i = 0; i < _enabledAuctions.length; ++i) {
if (isActive(_enabledAuctions[i])) {
return true;
}
}
return false;
}
/**
* @notice Sets the starting price for the auction.
* @dev This is an unscaled "lot size" essentially to start the pricing in "want".
* The kicked amount of _from is divided by this to get the per auction initial price.
* @param _startingPrice The new starting price for the auction.
*/
function setStartingPrice(
uint256 _startingPrice
) external virtual onlyGovernance {
require(_startingPrice != 0, "starting price");
// Don't change the price when an auction is active.
require(!isAnActiveAuction(), "active auction");
startingPrice = _startingPrice;
emit UpdatedStartingPrice(_startingPrice);
}
/**
* @notice Sets the step decay rate for the auction.
* @dev The decay rate is in basis points (e.g., 50 for 0.5% decay per step).
* @param _stepDecayRate The new decay rate per step in basis points (max 10000 = 100%).
*/
function setStepDecayRate(
uint256 _stepDecayRate
) external virtual onlyGovernance {
require(
_stepDecayRate > 0 && _stepDecayRate < 10_000,
"invalid decay rate"
);
// Don't change the decay rate when an auction is active.
require(!isAnActiveAuction(), "active auction");
stepDecayRate = _stepDecayRate;
emit UpdatedStepDecayRate(_stepDecayRate);
}
/**
* @notice Sets the step duration for the auction.
* @param _stepDuration The new step duration in seconds.
*/
function setStepDuration(
uint256 _stepDuration
) external virtual onlyGovernance {
require(
_stepDuration != 0 && _stepDuration < AUCTION_LENGTH,
"invalid step duration"
);
require(!isAnActiveAuction(), "active auction");
stepDuration = _stepDuration;
emit UpdatedStepDuration(_stepDuration);
}
/**
* @notice Sets whether we let cow solvers use the next price.
* @dev Because COW takes several blocks to solve, we know that other takers will beat them to the current price.
* @param _letCowPeek Whether we let cow solvers peek at the next price.
*/
function setLetCowPeek(bool _letCowPeek) external virtual onlyGovernance {
letCowPeek = _letCowPeek;
emit UpdatedLetCowPeek(_letCowPeek);
}
/*//////////////////////////////////////////////////////////////
PARTICIPATE IN AUCTION
//////////////////////////////////////////////////////////////*/
/**
* @notice Kicks off an auction, updating its status and making funds available for bidding.
* @param _from The address of the token to be auctioned.
* @return _available The available amount for bidding on in the auction.
*/
function kick(
address _from
) external virtual nonReentrant returns (uint256 _available) {
return _kick(_from);
}
function _kick(
address _from
) internal virtual returns (uint256 _available) {
require(auctions[_from].scaler != 0, "not enabled");
require(
block.timestamp > auctions[_from].kicked + AUCTION_LENGTH,
"too soon"
);
// Just use current balance.
_available = ERC20(_from).balanceOf(address(this));
require(_available != 0, "nothing to kick");
// Update the auctions status.
auctions[_from].kicked = uint64(block.timestamp);
auctions[_from].initialAvailable = uint128(_available);
emit AuctionKicked(_from, _available);
}
/**
* @notice Take the token being sold in a live auction.
* @dev Defaults to taking the full amount and sending to the msg sender.
* @param _from The address of the token to be auctioned.
* @return . The amount of fromToken taken in the auction.
*/
function take(address _from) external virtual returns (uint256) {
return _take(_from, type(uint256).max, msg.sender, new bytes(0));
}
/**
* @notice Take the token being sold in a live auction with a specified maximum amount.
* @dev Will send the funds to the msg sender.
* @param _from The address of the token to be auctioned.
* @param _maxAmount The maximum amount of fromToken to take in the auction.
* @return . The amount of fromToken taken in the auction.
*/
function take(
address _from,
uint256 _maxAmount
) external virtual returns (uint256) {
return _take(_from, _maxAmount, msg.sender, new bytes(0));
}
/**
* @notice Take the token being sold in a live auction.
* @param _from The address of the token to be auctioned.
* @param _maxAmount The maximum amount of fromToken to take in the auction.
* @param _takerReceiver The address that will receive the fromToken.
* @return _amountTaken The amount of fromToken taken in the auction.
*/
function take(
address _from,
uint256 _maxAmount,
address _takerReceiver
) external virtual returns (uint256) {
return _take(_from, _maxAmount, _takerReceiver, new bytes(0));
}
/**
* @notice Take the token being sold in a live auction.
* @param _from The address of the token to be auctioned.
* @param _maxAmount The maximum amount of fromToken to take in the auction.
* @param _takerReceiver The address that will receive the fromToken.
* @param _data The data signify the callback should be used and sent with it.
* @return _amountTaken The amount of fromToken taken in the auction.
*/
function take(
address _from,
uint256 _maxAmount,
address _takerReceiver,
bytes calldata _data
) external virtual returns (uint256) {
return _take(_from, _maxAmount, _takerReceiver, _data);
}
/// @dev Implements the take of the auction.
function _take(
address _from,
uint256 _maxAmount,
address _takerReceiver,
bytes memory _data
) internal virtual nonReentrant returns (uint256 _amountTaken) {
AuctionInfo memory auction = auctions[_from];
// Make sure the auction is active.
require(
auction.kicked + AUCTION_LENGTH >= block.timestamp,
"not kicked"
);
// Max amount that can be taken.
uint256 _available = available(_from);
_amountTaken = _available > _maxAmount ? _maxAmount : _available;
// Get the amount needed
uint256 needed = _getAmountNeeded(
auction,
_amountTaken,
block.timestamp
);
require(needed != 0, "zero needed");
// Send `from`.
ERC20(_from).safeTransfer(_takerReceiver, _amountTaken);
// If the caller has specified data.
if (_data.length != 0) {
// Do the callback.
ITaker(_takerReceiver).auctionTakeCallback(
_from,
msg.sender,
_amountTaken,
needed,
_data
);
}
// Cache the want address.
address _want = want();
// Pull `want`.
ERC20(_want).safeTransferFrom(msg.sender, receiver, needed);
// If the full amount is taken, end the auction.
if (_amountTaken == _available) {
auctions[_from].kicked = uint64(0);
emit AuctionSettled(_from);
}
}
/// @dev Validates a COW order signature.
function isValidSignature(
bytes32 _hash,
bytes calldata signature
) external view returns (bytes4) {
// Make sure `_take` has not already been entered.
require(!_reentrancyGuardEntered(), "ReentrancyGuard: reentrant call");
// Decode the signature to get the order.
GPv2Order.Data memory order = abi.decode(signature, (GPv2Order.Data));
AuctionInfo memory auction = auctions[address(order.sellToken)];
// Get the current amount needed for the auction.
uint256 paymentAmount;
// if enabled, get the next payment amount to let cow peek
if (letCowPeek) {
paymentAmount = _getAmountNeeded(
auction,
order.sellAmount,
block.timestamp + stepDuration
);
} else {
paymentAmount = _getAmountNeeded(
auction,
order.sellAmount,
block.timestamp
);
}
// Verify the order details.
// Retreive domain seperator each time for chains it is not deployed on yet
require(
_hash ==
order.hash(ICowSettlement(COW_SETTLEMENT).domainSeparator()),
"bad order"
);
require(paymentAmount != 0, "zero amount");
require(available(address(order.sellToken)) != 0, "zero available");
require(order.feeAmount == 0, "fee");
require(order.partiallyFillable, "partial fill");
require(order.validTo < auction.kicked + AUCTION_LENGTH, "expired");
require(order.appData == bytes32(0), "app data");
require(order.buyAmount >= paymentAmount, "bad price");
require(address(order.buyToken) == want(), "bad token");
require(order.receiver == receiver, "bad receiver");
require(order.sellAmount <= auction.initialAvailable, "bad amount");
// If all checks pass, return the magic value
return this.isValidSignature.selector;
}
/**
* @notice Forces the auction to be kicked.
* @dev Only callable by governance in replace of sweep settle and kick.
* @param _from The address of the token to be auctioned.
*/
function forceKick(address _from) external onlyGovernance {
auctions[_from].kicked = uint64(0);
_kick(_from);
}
/**
* @notice Allows the auction to be stopped if the full amount is taken.
* @param _from The address of the token to be auctioned.
*/
function settle(address _from) external virtual {
require(isActive(_from), "!active");
require(ERC20(_from).balanceOf(address(this)) == 0, "!empty");
auctions[_from].kicked = uint64(0);
emit AuctionSettled(_from);
}
function sweep(address _token) external virtual onlyGovernance {
ERC20(_token).safeTransfer(
msg.sender,
ERC20(_token).balanceOf(address(this))
);
emit AuctionSwept(_token, msg.sender);
}
}
"
},
"src/utils/ClonableCreate2.sol": {
"content": "// SPDX-License-Identifier: AGPL-3.0
pragma solidity >=0.8.18;
import {Clonable} from "./Clonable.sol";
contract ClonableCreate2 is Clonable {
/**
* @notice Clone the contracts default `original` contract using CREATE2.
* @param salt The salt to use for deterministic deployment.
* @return Address of the new Minimal Proxy clone.
*/
function _cloneCreate2(bytes32 salt) internal virtual returns (address) {
return _cloneCreate2(original, salt);
}
/**
* @notice Clone any `_original` contract using CREATE2.
* @param _original The address of the contract to clone.
* @param salt The salt to use for deterministic deployment.
* @return _newContract Address of the new Minimal Proxy clone.
*/
function _cloneCreate2(
address _original,
bytes32 salt
) internal virtual returns (address _newContract) {
// Hash the salt with msg.sender to protect deployments for specific callers
bytes32 finalSalt = getSalt(salt, msg.sender);
address predicted = computeCreate2Address(_original, salt, msg.sender);
bytes20 addressBytes = bytes20(_original);
assembly {
// EIP-1167 bytecode
let clone_code := mload(0x40)
mstore(
clone_code,
0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000
)
mstore(add(clone_code, 0x14), addressBytes)
mstore(
add(clone_code, 0x28),
0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
)
_newContract := create2(0, clone_code, 0x37, finalSalt)
}
require(
_newContract != address(0) && _newContract == predicted,
"ClonableCreate2: create2 failed"
);
}
/**
* @notice Compute the address where a clone would be deployed using CREATE2.
* @param salt The salt to use for address computation.
* @return The address where the clone would be deployed.
*/
function computeCreate2Address(
bytes32 salt
) external view virtual returns (address) {
return computeCreate2Address(original, salt, msg.sender);
}
/**
* @notice Compute the address where a clone would be deployed using CREATE2.
* @param _original The address of the contract to clone.
* @param salt The salt to use for address computation.
* @return predicted address where the clone would be deployed.
*/
function computeCreate2Address(
address _original,
bytes32 salt
) external view virtual returns (address predicted) {
return computeCreate2Address(_original, salt, msg.sender);
}
/**
* @notice Compute the address where a clone would be deployed using CREATE2.
* @param _original The address of the contract to clone.
* @param salt The salt to use for address computation.
* @return predicted The address where the clone would be deployed.
*/
function computeCreate2Address(
address _original,
bytes32 salt,
address deployer
) public view virtual returns (address predicted) {
// Hash the salt with msg.sender to match deployment behavior
bytes32 finalSalt = getSalt(salt, deployer);
bytes20 addressBytes = bytes20(_original);
assembly {
let ptr := mload(0x40)
// Store the prefix
mstore(
ptr,
0x3d602d80600a3d3981f3363d3d373d3d3d363d73000000000000000000000000
)
// Store the address
mstore(add(ptr, 0x14), addressBytes)
// Store the suffix
mstore(
add(ptr, 0x28),
0x5af43d82803e903d91602b57fd5bf30000000000000000000000000000000000
)
// Compute init code hash
let initCodeHash := keccak256(ptr, 0x37)
// Compute the CREATE2 address
// 0xff ++ address(this) ++ salt ++ initCodeHash
mstore(ptr, 0xff)
mstore8(ptr, 0xff)
mstore(add(ptr, 0x01), shl(96, address()))
mstore(add(ptr, 0x15), finalSalt)
mstore(add(ptr, 0x35), initCodeHash)
predicted := keccak256(ptr, 0x55)
}
}
/**
* @dev Internal function to compute the final salt by hashing with msg.sender.
* This ensures that different callers get different deployment addresses
* even when using the same salt value.
* @param salt The user-provided salt.
* @return The final salt to use for CREATE2.
*/
function getSalt(
bytes32 salt,
address deployer
) public view virtual returns (bytes32) {
return keccak256(abi.encodePacked(salt, deployer));
}
}
"
},
"src/libraries/Maths.sol": {
"content": "// SPDX-License-Identifier: GPL-3.0-or-later
pragma solidity >=0.8.18;
// Math library from https://github.com/ajna-finance/ajna-core/blob/master/src/libraries/internal/Maths.sol
/**
@title Maths library
@notice Internal library containing common maths.
*/
library Maths {
uint256 internal constant WAD = 1e18;
uint256 internal constant RAY = 1e27;
function wmul(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * y + WAD / 2) / WAD;
}
function floorWmul(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * y) / WAD;
}
function ceilWmul(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * y + WAD - 1) / WAD;
}
function wdiv(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * WAD + y / 2) / y;
}
function floorWdiv(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * WAD) / y;
}
function ceilWdiv(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * WAD + y - 1) / y;
}
function ceilDiv(uint256 x, uint256 y) internal pure returns (uint256) {
return (x + y - 1) / y;
}
function max(uint256 x, uint256 y) internal pure returns (uint256) {
return x >= y ? x : y;
}
function min(uint256 x, uint256 y) internal pure returns (uint256) {
return x <= y ? x : y;
}
function wad(uint256 x) internal pure returns (uint256) {
return x * WAD;
}
function rmul(uint256 x, uint256 y) internal pure returns (uint256) {
return (x * y + RAY / 2) / RAY;
}
function rpow(uint256 x, uint256 n) internal pure returns (uint256 z) {
z = n % 2 != 0 ? x : RAY;
for (n /= 2; n != 0; n /= 2) {
x = rmul(x, x);
if (n % 2 != 0) {
z = rmul(z, x);
}
}
}
/*************************/
/*** Integer Functions ***/
/*************************/
function maxInt(int256 x, int256 y) internal pure returns (int256) {
return x >= y ? x : y;
}
function minInt(int256 x, int256 y) internal pure returns (int256) {
return x <= y ? x : y;
}
}
"
},
"src/interfaces/ITaker.sol": {
"content": "// SPDX-License-Identifier: AGPL-3.0
pragma solidity >=0.8.18;
interface ITaker {
function auctionTakeCallback(
address _from,
address _sender,
uint256 _amountTaken,
uint256 _amountNeeded,
bytes calldata _data
) external;
}
"
},
"src/libraries/GPv2Order.sol": {
"content": "// SPDX-License-Identifier: LGPL-3.0-or-later
pragma solidity ^0.8.0;
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
/// @title Gnosis Protocol v2 Order Library
/// @author Gnosis Developers
library GPv2Order {
/// @dev The complete data for a Gnosis Protocol order. This struct contains
/// all order parameters that are signed for submitting to GP.
struct Data {
ERC20 sellToken;
ERC20 buyToken;
address receiver;
uint256 sellAmount;
uint256 buyAmount;
uint32 validTo;
bytes32 appData;
uint256 feeAmount;
bytes32 kind;
bool partiallyFillable;
bytes32 sellTokenBalance;
bytes32 buyTokenBalance;
}
/// @dev The order EIP-712 type hash for the [`GPv2Order.Data`] struct.
///
/// This value is pre-computed from the following expression:
/// ```
/// keccak256(
/// "Order(" +
/// "address sellToken," +
/// "address buyToken," +
/// "address receiver," +
/// "uint256 sellAmount," +
/// "uint256 buyAmount," +
/// "uint32 validTo," +
/// "bytes32 appData," +
/// "uint256 feeAmount," +
/// "string kind," +
/// "bool partiallyFillable" +
/// "string sellTokenBalance" +
/// "string buyTokenBalance" +
/// ")"
/// )
/// ```
bytes32 internal constant TYPE_HASH =
hex"d5a25ba2e97094ad7d83dc28a6572da797d6b3e7fc6663bd93efb789fc17e489";
/// @dev The marker value for a sell order for computing the order struct
/// hash. This allows the EIP-712 compatible wallets to display a
/// descriptive string for the order kind (instead of 0 or 1).
///
/// This value is pre-computed from the following expression:
/// ```
/// keccak256("sell")
/// ```
bytes32 internal constant KIND_SELL =
hex"f3b277728b3fee749481eb3e0b3b48980dbbab78658fc419025cb16eee346775";
/// @dev The OrderKind marker value for a buy order for computing the order
/// struct hash.
///
/// This value is pre-computed from the following expression:
/// ```
/// keccak256("buy")
/// ```
bytes32 internal constant KIND_BUY =
hex"6ed88e868af0a1983e3886d5f3e95a2fafbd6c3450bc229e27342283dc429ccc";
/// @dev The TokenBalance marker value for using direct ERC20 balances for
/// computing the order struct hash.
///
/// This value is pre-computed from the following expression:
/// ```
/// keccak256("erc20")
/// ```
bytes32 internal constant BALANCE_ERC20 =
hex"5a28e9363bb942b639270062aa6bb295f434bcdfc42c97267bf003f272060dc9";
/// @dev The TokenBalance marker value for using Balancer Vault external
/// balances (in order to re-use Vault ERC20 approvals) for computing the
/// order struct hash.
///
/// This value is pre-computed from the following expression:
/// ```
/// keccak256("external")
/// ```
bytes32 internal constant BALANCE_EXTERNAL =
hex"abee3b73373acd583a130924aad6dc38cfdc44ba0555ba94ce2ff63980ea0632";
/// @dev The TokenBalance marker value for using Balancer Vault internal
/// balances for computing the order struct hash.
///
/// This value is pre-computed from the following expression:
/// ```
/// keccak256("internal")
/// ```
bytes32 internal constant BALANCE_INTERNAL =
hex"4ac99ace14ee0a5ef932dc609df0943ab7ac16b7583634612f8dc35a4289a6ce";
/// @dev Marker address used to indicate that the receiver of the trade
/// proceeds should the owner of the order.
///
/// This is chosen to be `address(0)` for gas efficiency as it is expected
/// to be the most common case.
address internal constant RECEIVER_SAME_AS_OWNER = address(0);
/// @dev The byte length of an order unique identifier.
uint256 internal constant UID_LENGTH = 56;
/// @dev Returns the actual receiver for an order. This function checks
/// whether or not the [`receiver`] field uses the marker value to indicate
/// it is the same as the order owner.
///
/// @return receiver The actual receiver of trade proceeds.
function actualReceiver(
Data memory order,
address owner
) internal pure returns (address receiver) {
if (order.receiver == RECEIVER_SAME_AS_OWNER) {
receiver = owner;
} else {
receiver = order.receiver;
}
}
/// @dev Return the EIP-712 signing hash for the specified order.
///
/// @param order The order to compute the EIP-712 signing hash for.
/// @param domainSeparator The EIP-712 domain separator to use.
/// @return orderDigest The 32 byte EIP-712 struct hash.
function hash(
Data memory order,
bytes32 domainSeparator
) internal pure returns (bytes32 orderDigest) {
bytes32 structHash;
// NOTE: Compute the EIP-712 order struct hash in place. As suggested
// in the EIP proposal, noting that the order struct has 10 fields, and
// including the type hash `(12 + 1) * 32 = 416` bytes to hash.
// <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md#rationale-for-encodedata>
// solhint-disable-next-line no-inline-assembly
assembly {
let dataStart := sub(order, 32)
let temp := mload(dataStart)
mstore(dataStart, TYPE_HASH)
structHash := keccak256(dataStart, 416)
mstore(dataStart, temp)
}
// NOTE: Now that we have the struct hash, compute the EIP-712 signing
// hash using scratch memory past the free memory pointer. The signing
// hash is computed from `"\x19\x01" || domainSeparator || structHash`.
// <https://docs.soliditylang.org/en/v0.7.6/internals/layout_in_memory.html#layout-in-memory>
// <https://github.com/ethereum/EIPs/blob/master/EIPS/eip-712.md#specification>
// solhint-disable-next-line no-inline-assembly
assembly {
let freeMemoryPointer := mload(0x40)
mstore(freeMemoryPointer, "\x19\x01")
mstore(add(freeMemoryPointer, 2), domainSeparator)
mstore(add(freeMemoryPointer, 34), structHash)
orderDigest := keccak256(freeMemoryPointer, 66)
}
}
/// @dev Packs order UID parameters into the specified memory location. The
/// result is equivalent to `abi.encodePacked(...)` with the difference that
/// it allows re-using the memory for packing the order UID.
///
/// This function reverts if the order UID buffer is not the correct size.
///
/// @param orderUid The buffer pack the order UID parameters into.
/// @param orderDigest The EIP-712 struct digest derived from the order
/// parameters.
/// @param owner The address of the user who owns this order.
/// @param validTo The epoch time at which the order will stop being valid.
function packOrderUidParams(
bytes memory orderUid,
bytes32 orderDigest,
address owner,
uint32 validTo
) internal pure {
require(orderUid.length == UID_LENGTH, "GPv2: uid buffer overflow");
// NOTE: Write the order UID to the allocated memory buffer. The order
// parameters are written to memory in **reverse order** as memory
// operations write 32-bytes at a time and we want to use a packed
// encoding. This means, for example, that after writing the value of
// `owner` to bytes `20:52`, writing the `orderDigest` to bytes `0:32`
// will **overwrite** bytes `20:32`. This is desirable as addresses are
// only 20 bytes and `20:32` should be `0`s:
//
// | 1111111111222222222233333333334444444444555555
// byte | 01234567890123456789012345678901234567890123456789012345
// -------+---------------------------------------------------------
// field | [.........orderDigest..........][......owner.......][vT]
// -------+---------------------------------------------------------
// mstore | [000000000000000000000000000.vT]
// | [00000000000.......owner.......]
// | [.........orderDigest..........]
//
// Additionally, since Solidity `bytes memory` are length prefixed,
// 32 needs to be added to all the offsets.
//
// solhint-disable-next-line no-inline-assembly
assembly {
mstore(add(orderUid, 56), validTo)
mstore(add(orderUid, 52), owner)
mstore(add(orderUid, 32), orderDigest)
}
}
/// @dev Extracts specific order information from the standardized unique
/// order id of the protocol.
///
/// @param orderUid The unique identifier used to represent an order in
/// the protocol. This uid is the packed concatenation of the order digest,
/// the validTo order parameter and the address of the user who created the
/// order. It is used by the user to interface with the contract directly,
/// and not by calls that are triggered by the solvers.
/// @return orderDigest The EIP-712 signing digest derived from the order
/// parameters.
/// @return owner The address of the user who owns this order.
/// @return validTo The epoch time at which the order will stop being valid.
function extractOrderUidParams(
bytes calldata orderUid
)
internal
pure
returns (bytes32 orderDigest, address owner, uint32 validTo)
{
require(orderUid.length == UID_LENGTH, "GPv2: invalid uid");
// Use assembly to efficiently decode packed calldata.
// solhint-disable-next-line no-inline-assembly
assembly {
orderDigest := calldataload(orderUid.offset)
owner := shr(96, calldataload(add(orderUid.offset, 32)))
validTo := shr(224, calldataload(add(orderUid.offset, 52)))
}
}
}
"
},
"src/utils/Governance2Step.sol": {
"content": "// SPDX-License-Identifier: AGPL-3.0
pragma solidity >=0.8.18;
import {Governance} from "./Governance.sol";
contract Governance2Step is Governance {
/// @notice Emitted when the pending governance address is set.
event UpdatePendingGovernance(address indexed newPendingGovernance);
/// @notice Address that is set to take over governance.
address public pendingGovernance;
constructor(address _governance) Governance(_governance) {}
/**
* @notice Sets a new address as the `pendingGovernance` of the contract.
* @dev Throws if the caller is not current governance.
* @param _newGovernance The new governance address.
*/
function transferGovernance(
address _newGovernance
) external virtual override onlyGovernance {
require(_newGovernance != address(0), "ZERO ADDRESS");
pendingGovernance = _newGovernance;
emit UpdatePendingGovernance(_newGovernance);
}
/**
* @notice Allows the `pendingGovernance` to accept the role.
*/
function acceptGovernance() external virtual {
require(msg.sender == pendingGovernance, "!pending governance");
emit GovernanceTransferred(governance, msg.sender);
governance = msg.sender;
pendingGovernance = address(0);
}
}
"
},
"lib/openzeppelin-contracts/contracts/token/ERC20/ERC20.sol": {
"content": "// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (token/ERC20/ERC20.sol)
pragma solidity ^0.8.0;
import "./IERC20.sol";
import "./extensions/IERC20Metadata.sol";
import "../../utils/Context.sol";
/**
* @dev Implementation of the {IERC20} interface.
*
* This implementation is agnostic to the way tokens are created. This means
* that a supply mechanism has to be added in a derived contract using {_mint}.
* For a generic mechanism see {ERC20PresetMinterPauser}.
*
* TIP: For a detailed writeup see our guide
* https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
* to implement supply mechanisms].
*
* The default value of {decimals} is 18. To change this, you should override
* this function so it returns a different value.
*
* We have followed general OpenZeppelin Contracts guidelines: functions revert
* instead returning `false` on failure. This behavior is nonetheless
* conventional and does not conflict with the expectations of ERC20
* applications.
*
* Additionally, an {Approval} event is emitted on calls to {transferFrom}.
* This allows applications to reconstruct the allowance for all accounts just
* by listening to said events. Other implementations of the EIP may not emit
* these events, as it isn't required by the specification.
*
* Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
* functions have been added to mitigate the well-known issues around setting
* allowances. See {IERC20-approve}.
*/
contract ERC20 is Context, IERC20, IERC20Metadata {
mapping(address => uint256) private _balances;
mapping(address => mapping(address => uint256)) private _allowances;
uint256 private _totalSupply;
string private _name;
string private _symbol;
/**
* @dev Sets the values for {name} and {symbol}.
*
* All two of these values are immutable: they can only be set once during
* construction.
*/
constructor(string memory name_, string memory symbol_) {
_name = name_;
_symbol = symbol_;
}
/**
* @dev Returns the name of the token.
*/
function name() public view virtual override returns (string memory) {
return _name;
}
/**
* @dev Returns the symbol of the token, usually a shorter version of the
* name.
*/
function symbol() public view virtual override returns (string memory) {
return _symbol;
}
/**
* @dev Returns the number of decimals used to get its user representation.
* For example, if `decimals` equals `2`, a balance of `505` tokens should
* be displayed to a user as `5.05` (`505 / 10 ** 2`).
*
* Tokens usually opt for a value of 18, imitating the relationship between
* Ether and Wei. This is the default value returned by this function, unless
* it's overridden.
*
* NOTE: This information is only used for _display_ purposes: it in
* no way affects any of the arithmetic of the contract, including
* {IERC20-balanceOf} and {IERC20-transfer}.
*/
function decimals() public view virtual override returns (uint8) {
return 18;
}
/**
* @dev See {IERC20-totalSupply}.
*/
function totalSupply() public view virtual override returns (uint256) {
return _totalSupply;
}
/**
* @dev See {IERC20-balanceOf}.
*/
function balanceOf(address account) public view virtual override returns (uint256) {
return _balances[account];
}
/**
* @dev See {IERC20-transfer}.
*
* Requirements:
*
* - `to` cannot be the zero address.
* - the caller must have a balance of at least `amount`.
*/
function transfer(address to, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_transfer(owner, to, amount);
return true;
}
/**
* @dev See {IERC20-allowance}.
*/
function allowance(address owner, address spender) public view virtual override returns (uint256) {
return _allowances[owner][spender];
}
/**
* @dev See {IERC20-approve}.
*
* NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
* `transferFrom`. This is semantically equivalent to an infinite approval.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function approve(address spender, uint256 amount) public virtual override returns (bool) {
address owner = _msgSender();
_approve(owner, spender, amount);
return true;
}
/**
* @dev See {IERC20-transferFrom}.
*
* Emits an {Approval} event indicating the updated allowance. This is not
* required by the EIP. See the note at the beginning of {ERC20}.
*
* NOTE: Does not update the allowance if the current allowance
* is the maximum `uint256`.
*
* Requirements:
*
* - `from` and `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
* - the caller must have allowance for ``from``'s tokens of at least
* `amount`.
*/
function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
address spender = _msgSender();
_spendAllowance(from, spender, amount);
_transfer(from, to, amount);
return true;
}
/**
* @dev Atomically increases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
*/
function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
address owner = _msgSender();
_approve(owner, spender, allowance(owner, spender) + addedValue);
return true;
}
/**
* @dev Atomically decreases the allowance granted to `spender` by the caller.
*
* This is an alternative to {approve} that can be used as a mitigation for
* problems described in {IERC20-approve}.
*
* Emits an {Approval} event indicating the updated allowance.
*
* Requirements:
*
* - `spender` cannot be the zero address.
* - `spender` must have allowance for the caller of at least
* `subtractedValue`.
*/
function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
address owner = _msgSender();
uint256 currentAllowance = allowance(owner, spender);
require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
unchecked {
_approve(owner, spender, currentAllowance - subtractedValue);
}
return true;
}
/**
* @dev Moves `amount` of tokens from `from` to `to`.
*
* This internal function is equivalent to {transfer}, and can be used to
* e.g. implement automatic token fees, slashing mechanisms, etc.
*
* Emits a {Transfer} event.
*
* Requirements:
*
* - `from` cannot be the zero address.
* - `to` cannot be the zero address.
* - `from` must have a balance of at least `amount`.
*/
function _transfer(address from, address to, uint256 amount) internal virtual {
require(from != address(0), "ERC20: transfer from the zero address");
require(to != address(0), "ERC20: transfer to the zero address");
_beforeTokenTransfer(from, to, amount);
uint256 fromBalance = _balances[from];
require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
unchecked {
_balances[from] = fromBalance - amount;
// Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
// decrementing then incrementing.
_balances[to] += amount;
}
emit Transfer(from, to, amount);
_afterTokenTransfer(from, to, amount);
}
/** @dev Creates `amount` tokens and assigns them to `account`, increasing
* the total supply.
*
* Emits a {Transfer} event with `from` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
*/
function _mint(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: mint to the zero address");
_beforeTokenTransfer(address(0), account, amount);
_totalSupply += amount;
unchecked {
// Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
_balances[account] += amount;
}
emit Transfer(address(0), account, amount);
_afterTokenTransfer(address(0), account, amount);
}
/**
* @dev Destroys `amount` tokens from `account`, reducing the
* total supply.
*
* Emits a {Transfer} event with `to` set to the zero address.
*
* Requirements:
*
* - `account` cannot be the zero address.
* - `account` must have at least `amount` tokens.
*/
function _burn(address account, uint256 amount) internal virtual {
require(account != address(0), "ERC20: burn from the zero address");
_beforeTokenTransfer(account, address(0), amount);
uint256 accountBalance = _balances[account];
require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
unchecked {
_balances[account] = accountBalance - amount;
// Overflow not possible: amount <= accountBalance <= totalSupply.
_totalSupply -= amount;
}
emit Transfer(account, address(0), amount);
_afterTokenTransfer(account, address(0), amount);
}
/**
* @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
*
* This internal function is equivalent to `approve`, and can be used to
* e.g. set automatic allowances for certain subsystems, etc.
*
* Emits an {Approval} event.
*
* Requirements:
*
* - `owner` cannot be the zero address.
* - `spender` cannot be the zero address.
*/
function _approve(address owner, address spender, uint256 amount) internal virtual {
require(owner != address(0), "ERC20: approve from the zero address");
require(spender != address(0), "ERC20: approve to the zero address");
_allowances[owner][spender] = amount;
emit Approval(owner, spender, amount);
}
/**
* @dev Updates `owner` s allowance for `spender` based on spent `amount`.
*
* Does not update the allowance amount in case of infinite allowance.
* Revert if not enough allowance is available.
*
* Might emit an {Approval} event.
*/
function _spendAllowance(address owner, address spender, uint256 amount) internal virtual {
uint256 currentAllowance = allowance(owner, spender);
if (currentAllowance != type(uint256).max) {
require(currentAllowance >= amount, "ERC20: insufficient allowance");
unchecked {
_approve(owner, spender, currentAllowance - amount);
}
}
}
/**
* @dev Hook that is called before any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* will be transferred to `to`.
* - when `from` is zero, `amount` tokens will be minted for `to`.
* - when `to` is zero, `amount` of ``from``'s tokens will be burned.
* - `from` and `to` are never both zero.
*
* To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
*/
function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}
/**
* @dev Hook that is called after any transfer of tokens. This includes
* minting and burning.
*
* Calling conditions:
*
* - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
* has been transferred to `to`.
* - when `from` is zero, `amount` tokens have been minted for `to`.
* - when `to` is zeSubmitted on: 2025-09-20 22:37:26
Comments
Log in to comment.
No comments yet.