dutch-auction-patterns

Dutch Auction Patterns

How Dutch Auctions Work

Price starts high and decreases over time until buyers step in. This is inherently fair — buyers pay their maximum willingness-to-pay, and price discovery happens naturally.

price(t) = startPrice - (startPrice - endPrice) * elapsed / duration   // linear
price(t) = startPrice * decay^elapsed                                  // exponential

Linear Dutch Auction

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.20;

import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
import {SafeERC20} from "@openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol";
import {ReentrancyGuard} from "@openzeppelin/contracts/utils/ReentrancyGuard.sol";

contract DutchAuction is ReentrancyGuard {
    using SafeERC20 for IERC20;

    IERC20 public immutable token;
    address public immutable seller;

    uint256 public immutable startPrice;
    uint256 public immutable endPrice;
    uint256 public immutable startTime;
    uint256 public immutable duration;
    uint256 public immutable totalTokens;
    uint256 public tokensSold;

    constructor(
        IERC20 _token,
        uint256 _startPrice,
        uint256 _endPrice,
        uint256 _startTime,
        uint256 _duration,
        uint256 _totalTokens
    ) {
        require(_startPrice > _endPrice, "start must exceed end");
        require(_startTime >= block.timestamp, "start in future");
        require(_duration > 0, "duration > 0");

        token = _token;
        seller = msg.sender;
        startPrice = _startPrice;
        endPrice = _endPrice;
        startTime = _startTime;
        duration = _duration;
        totalTokens = _totalTokens;
    }

    function currentPrice() public view returns (uint256) {
        if (block.timestamp < startTime) return startPrice;

        uint256 elapsed = block.timestamp - startTime;
        if (elapsed >= duration) return endPrice;

        uint256 priceDrop = (startPrice - endPrice) * elapsed / duration;
        return startPrice - priceDrop;
    }

    function buy(uint256 amount) external payable nonReentrant {
        require(block.timestamp >= startTime, "not started");
        require(tokensSold + amount <= totalTokens, "sold out");

        uint256 price = currentPrice();
        uint256 cost = price * amount / 1e18;
        require(msg.value >= cost, "insufficient payment");

        tokensSold += amount;
        token.safeTransfer(msg.sender, amount);

        uint256 refund = msg.value - cost;
        if (refund > 0) {
            (bool ok, ) = msg.sender.call{value: refund}("");
            require(ok, "refund failed");
        }

        emit Purchase(msg.sender, amount, price);
    }

    function withdrawProceeds() external {
        require(msg.sender == seller, "only seller");
        (bool ok, ) = seller.call{value: address(this).balance}("");
        require(ok, "transfer failed");
    }

    function withdrawUnsold() external {
        require(msg.sender == seller, "only seller");
        require(block.timestamp >= startTime + duration, "auction active");
        uint256 unsold = totalTokens - tokensSold;
        if (unsold > 0) token.safeTransfer(seller, unsold);
    }

    event Purchase(address indexed buyer, uint256 amount, uint256 price);
}