[DRAFT] Encrypted Derivative Value (EDV) Auction Module

script/deploy/Deploy.s.sol

@@ -16,7 +16,7 @@ import {Module} from "src/modules/Modules.sol";
 import {Callbacks} from "src/lib/Callbacks.sol";
 
 // Auction modules
-import {EncryptedMarginalPrice} from "src/modules/auctions/batch/EMP.sol";
+import {EncryptedMarginalPrice} from "src/modules/auctions/batch/EMP/EMP.sol";
 import {FixedPriceSale} from "src/modules/auctions/atomic/FPS.sol";
 
 // Derivative modules

script/ops/test/TestData.s.sol

@@ -8,7 +8,7 @@ import {Script, console2} from "forge-std/Script.sol";
 import {BatchAuctionHouse} from "src/BatchAuctionHouse.sol";
 import {IAuctionHouse} from "src/interfaces/IAuctionHouse.sol";
 import {toKeycode, toVeecode} from "src/modules/Modules.sol";
-import {EncryptedMarginalPrice} from "src/modules/auctions/batch/EMP.sol";
+import {EncryptedMarginalPrice} from "src/modules/auctions/batch/EMP/EMP.sol";
 import {ECIES, Point} from "src/lib/ECIES.sol";
 import {uint2str} from "src/lib/Uint2Str.sol";
 

src/blast/modules/auctions/batch/BlastEMP.sol

@@ -1,7 +1,7 @@
 // SPDX-License-Identifier: BSL-1.1
 pragma solidity 0.8.19;
 
-import {EncryptedMarginalPrice} from "src/modules/auctions/batch/EMP.sol";
+import {EncryptedMarginalPrice} from "src/modules/auctions/batch/EMP/EMP.sol";
 import {BlastGas} from "src/blast/modules/BlastGas.sol";
 
 contract BlastEMP is EncryptedMarginalPrice, BlastGas {

src/interfaces/modules/auctions/IEncryptedDerivativeValue.sol

@@ -0,0 +1,213 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+pragma solidity >=0.8.0;
+
+import {Point} from "src/lib/ECIES.sol";
+
+/// @title  IEncryptedDerivativeValue
+/// @notice Interface for encrypted derivative value batch auctions
+/// @dev    This contract does not inherit from `BatchAuctionModule` in order to avoid conflicts. Implementing contracts should inherit from both `BatchAuctionModule` and this interface.
+interface IEncryptedDerivativeValue {
+    // ========== ERRORS ========== //
+
+    error Auction_InvalidKey();
+    error Auction_WrongState(uint96 lotId);
+    error Bid_WrongState(uint96 lotId, uint64 bidId);
+    error NotPermitted(address caller);
+
+    // ========== EVENTS ========== //
+
+    event BidDecrypted(uint96 indexed lotId, uint64 indexed bidId, uint128 value);
+
+    // ========== DATA STRUCTURES ========== //
+
+    /// @notice         Parameters that are used to set auction-specific data
+    ///
+    /// @param          price               The fixed price of the auction (quote tokens per base tokens)
+    /// @param          minValue            The minimum derivative value that a user must bid to be considered in the auction
+    /// @param          sortHighToLow       True if bid values are sorted high to low, false if low to high
+    /// @param          minFillPercent      The minimum percentage of capacity that the lot must fill in order to settle. Maximum value = 100_000 = 1e5.
+    /// @param          minBidSize          The minimum size of a bid in quote tokens
+    /// @param          publicKey           The public key used to encrypt bids
+    struct AuctionDataParams {
+        uint256 price;
+        uint128 minValue;
+        bool sortHighToLow;
+        uint24 minFillPercent;
+        uint256 minBidSize;
+        Point publicKey;
+    }
+
+    /// @notice     Parameters to the bid function
+    ///
+    /// @param      encryptedDerivativeValue    The encrypted derivative value of the bid
+    /// @param      bidPublicKey                The public key used to encrypt the bid
+    struct BidParams {
+        uint256 encryptedDerivativeValue;
+        Point bidPublicKey;
+    }
+
+    /// @notice     The status of an auction lot
+    enum LotStatus {
+        Created,
+        Decrypted,
+        Settled
+    }
+
+    /// @notice     The status of a bid
+    /// @dev        Bid status will also be set to claimed if the bid is cancelled/refunded
+    enum BidStatus {
+        Submitted,
+        Decrypted,
+        Claimed
+    }
+
+    /// @notice        Struct containing auction-specific data
+    ///
+    /// @param         nextBidId           The ID of the next bid to be submitted
+    /// @param         nextDecryptIndex    The index of the next bid to decrypt
+    /// @param         status              The status of the auction
+    /// @param         marginalBidId       The ID of the marginal bid (marking that bids following it are not filled)
+    /// @param         marginalValue       The marginal derivative value of the auction (determined at settlement, blank before)
+    /// @param         minValue            The minimum derivative value that a user must bid to be considered in the auction
+    /// @param         price               The fixed price of the auction (quote tokens per base token)
+    /// @param         minFilled           The minimum amount of the lot that must be filled
+    /// @param         minBidSize          The minimum size of a bid in quote tokens
+    /// @param         publicKey           The public key used to encrypt bids (a point on the alt_bn128 curve from the generator point (1,2))
+    /// @param         privateKey          The private key used to decrypt bids (not provided until after the auction ends)
+    /// @param         bidIds              The list of bid IDs to decrypt in order of submission, excluding cancelled bids
+    struct AuctionData {
+        uint64 nextBidId; // 8 +
+        uint64 nextDecryptIndex; // 8 +
+        LotStatus status; // 1 +
+        uint64 marginalBidId; // 8  = 25 - end of slot 1
+        uint128 marginalValue; // 16 +
+        uint128 minValue; // 16 = 32 - end of slot 2
+        uint256 price; // 32 - slot 3
+        uint256 minFilled; // 32 - slot 4
+        uint256 minBidSize; // 32 - slot 5
+        Point publicKey; // 64 - slots 6 and 7
+        uint256 privateKey; // 32 - slot 8
+        uint64[] bidIds; // slots 9+
+    }
+
+    /// @notice        Core data for a bid
+    ///
+    /// @param         bidder              The address of the bidder
+    /// @param         amount              The amount of the bid
+    /// @param         minAmountOut        The minimum amount out (not set until the bid is decrypted)
+    /// @param         referrer            The address of the referrer
+    /// @param         status              The status of the bid
+    struct Bid {
+        address bidder; // 20 +
+        uint96 amount; // 12 = 32 - end of slot 1
+        address referrer; // 20 +
+        BidStatus status; // 1 = 21 - end of slot 2
+        uint128 derivativeValue; // 16 - slot 3
+    }
+
+    /// @notice        Struct containing data for an encrypted bid
+    ///
+    /// @param         encryptedAmountOut  The encrypted derivative value. It is encrypted with a symmetric key that can be derived from the bidPubKey using the private key for the provided auction public key on the alt_bn128 curve
+    /// @param         bidPubKey           The alt_bn128 public key used to encrypt the amount out (see bid() for more details)
+    struct EncryptedBid {
+        uint256 encryptedDerivativeValue;
+        Point bidPubKey;
+    }
+
+    /// @notice        Struct containing partial fill data for a lot
+    ///
+    /// @param         bidId        The ID of the bid
+    /// @param         refund       The amount to refund to the bidder
+    /// @param         payout       The amount to payout to the bidder
+    struct PartialFill {
+        uint64 bidId; // 8 +
+        uint96 refund; // 12 = 20 - end of slot 1
+        uint256 payout; // 32 - slot 2
+    }
+
+    // ========== DECRYPTION ========== //
+
+    /// @notice Submits the private key for the auction lot and decrypts an initial number of bids
+    ///         It does not require gating. If the seller wishes to limit who can call, they can simply not reveal the key to anyone else.
+    ///         On the other hand, if a key management service is used, then anyone can call it once the key is revealed.
+    ///
+    /// @param  lotId_      The lot ID of the auction to submit the private key for
+    /// @param  privateKey_ The ECIES private key to decrypt the bids
+    /// @param  num_        The number of bids to decrypt after submitting the private key (passed to `_decryptAndSortBids()`)
+    /// @param  sortHints_  The sort hints for the bid decryption (passed to `_decryptAndSortBids()`)
+    function submitPrivateKey(
+        uint96 lotId_,
+        uint256 privateKey_,
+        uint64 num_,
+        bytes32[] calldata sortHints_
+    ) external;
+
+    /// @notice Decrypts a batch of bids and sorts them by price in descending order
+    ///
+    /// @param  lotId_      The lot ID
+    /// @param  num_        The number of bids to decrypt and sort
+    /// @param  sortHints_  The sort hints for the bids
+    function decryptAndSortBids(
+        uint96 lotId_,
+        uint64 num_,
+        bytes32[] calldata sortHints_
+    ) external;
+
+    /// @notice     Returns the decrypted amountOut of a single bid without altering contract state
+    ///
+    /// @param      lotId_            The lot ID of the auction to decrypt the bid for
+    /// @param      bidId_            The bid ID to decrypt
+    /// @return     derivativeValue   The decrypted derivative value
+    function decryptBid(
+        uint96 lotId_,
+        uint64 bidId_
+    ) external view returns (uint128 derivativeValue);
+
+    /// @notice     Returns the bid after `key_` in the queue
+    ///
+    /// @param      lotId_  The lot ID
+    /// @param      key_    The key to search for
+    /// @return     nextKey The key of the next bid in the queue
+    function getNextInQueue(uint96 lotId_, bytes32 key_) external view returns (bytes32 nextKey);
+
+    /// @notice     Returns the number of decrypted bids remaining in the queue
+    ///
+    /// @param      lotId_  The lot ID
+    /// @return     numBids The number of decrypted bids remaining in the queue
+    function getNumBidsInQueue(uint96 lotId_) external view returns (uint256 numBids);
+
+    /// @notice     Returns whether the lot sorts bids from high to low (true) or low to high (false)
+    function sortHighToLow(uint96 lotId_) external view returns (bool);
+
+    // ========== AUCTION INFORMATION ========== //
+
+    /// @notice Returns the `Bid` and `EncryptedBid` data for a given lot and bid ID
+    ///
+    /// @param  lotId_          The lot ID
+    /// @param  bidId_          The bid ID
+    /// @return bid             The `Bid` data
+    /// @return encryptedBid    The `EncryptedBid` data
+    function getBid(
+        uint96 lotId_,
+        uint64 bidId_
+    ) external view returns (Bid memory bid, EncryptedBid memory encryptedBid);
+
+    /// @notice Returns the `AuctionData` data for an auction lot
+    ///
+    /// @param  lotId_          The lot ID
+    /// @return auctionData_    The `AuctionData`
+    function getAuctionData(uint96 lotId_)
+        external
+        view
+        returns (AuctionData memory auctionData_);
+
+    /// @notice Returns the `PartialFill` data for an auction lot
+    ///
+    /// @param  lotId_          The lot ID
+    /// @return hasPartialFill  True if a partial fill exists
+    /// @return partialFill     The `PartialFill` data
+    function getPartialFill(uint96 lotId_)
+        external
+        view
+        returns (bool hasPartialFill, PartialFill memory partialFill);
+}