Understanding the Dutch Auction Mechanism

How the auction ensures fairness and market-driven pricing through a dynamic, blockchain-powered process

---

Understanding the Dutch Auction Mechanism

Welcome to our deep dive into the Dutch Auction Mechanism, a pivotal component of our NFT launch. At its core, a Dutch auction is a method of selling in which the price of the item is reduced until it finds a buyer. For our Blast Hoge NFTs, this approach ensures fairness and accessibility, allowing the market to determine the value dynamically.

Our implementation of the Dutch auction on the Blast network employs a sophisticated yet elegant series of smart contracts that guide the auction process, ensuring transparency and efficiency. These contracts leverage the power of blockchain to automate the auction, providing a seamless experience for participants. Let's explore the essence of this mechanism through key snippets from our smart contracts.

1. Logistic to Linear Transition

The LogisticToLinearVRGDA contract marks a pivotal transition from a logistic growth phase to a linear phase in our auction. This dual-phase approach ensures an adaptive pricing model, reflecting the evolving demand for our NFTs.

abstract contract LogisticToLinearVRGDA is LogisticVRGDA {
    int256 internal immutable soldBySwitch;
    int256 internal immutable switchTime;
    int256 internal immutable perTimeUnit;

    constructor(
        int256 _targetPrice,
        int256 _priceDecayPercent,
        ...
    ) LogisticVRGDA(_targetPrice, _priceDecayPercent, _logisticAsymptote, _timeScale) { ... }

    function getTargetSaleTime(int256 sold) public view virtual override returns (int256) {
        if (sold < soldBySwitch) return LogisticVRGDA.getTargetSaleTime(sold);
        return unsafeWadDiv(sold - soldBySwitch, perTimeUnit) + switchTime;
    }
}

This snippet showcases the logic determining the transition from a logistic to a linear pricing model, dictated by the number of tokens sold (soldBySwitch) and the target switch time (switchTime).

2. Variable Rate Gradual Dutch Auction (VRGDA) Pricing

The VRGDA contract is the backbone of our auction pricing mechanism. It calculates the price of tokens based on the time elapsed and the number of tokens sold, implementing a variable rate that reflects demand over time.

abstract contract VRGDA {
    int256 public immutable targetPrice;
    int256 internal immutable decayConstant;

    constructor(int256 _targetPrice, int256 _priceDecayPercent) { ... }

    function getVRGDAPrice(int256 timeSinceStart, uint256 sold) public view virtual returns (uint256) {
        return uint256(wadMul(targetPrice, wadExp(unsafeWadMul(decayConstant, timeSinceStart - getTargetSaleTime(toWadUnsafe(sold + 1))))));
    }
}

Here, the price calculation is a function of the decay constant and the target sale time, providing a flexible and dynamic pricing model through the auction.

3. Logistic Growth Phase

The LogisticVRGDA contract introduces a logistic growth model for the early phase of the auction, enabling a gradual increase in price that mirrors the initial interest and demand.

abstract contract LogisticVRGDA is VRGDA {
    int256 internal immutable logisticLimit;
    int256 internal immutable timeScale;

    function getTargetSaleTime(int256 sold) public view virtual override returns (int256) {
        return -unsafeWadDiv(wadLn(unsafeDiv(logisticLimitDoubled, sold + logisticLimit) - 1e18), timeScale);
    }
}

This segment emphasizes our approach to modeling the initial sales period with a logistic function, gradually transitioning to a linear model as the auction progresses.

This technical framework ensures that our auction is conducted fairly, transparently, and efficiently, reflecting the true market value of Blast Hoge NFTs.