package api import ( "database/sql" "errors" "net/http" "github.com/gin-gonic/gin" "github.com/hermeznetwork/hermez-node/common" "github.com/hermeznetwork/hermez-node/db/historydb" ) // SlotAPI is a repesentation of a slot information type SlotAPI struct { ItemID uint64 `json:"itemId"` SlotNum int64 `json:"slotNum"` FirstBlock int64 `json:"firstBlock"` LastBlock int64 `json:"lastBlock"` OpenAuction bool `json:"openAuction"` WinnerBid *historydb.BidAPI `json:"bestBid"` TotalItems uint64 `json:"-"` FirstItem uint64 `json:"-"` LastItem uint64 `json:"-"` } func (a *API) getFirstLastBlock(slotNum int64) (int64, int64) { genesisBlock := a.cg.AuctionConstants.GenesisBlockNum blocksPerSlot := int64(a.cg.AuctionConstants.BlocksPerSlot) firstBlock := slotNum*blocksPerSlot + genesisBlock lastBlock := (slotNum+1)*blocksPerSlot + genesisBlock - 1 return firstBlock, lastBlock } func (a *API) getCurrentSlot(currentBlock int64) int64 { genesisBlock := a.cg.AuctionConstants.GenesisBlockNum blocksPerSlot := int64(a.cg.AuctionConstants.BlocksPerSlot) currentSlot := (currentBlock - genesisBlock) / blocksPerSlot return currentSlot } func (a *API) isOpenAuction(currentBlock, slotNum int64, auctionVars common.AuctionVariables) bool { currentSlot := a.getCurrentSlot(currentBlock) closedAuctionSlots := currentSlot + int64(auctionVars.ClosedAuctionSlots) openAuctionSlots := int64(auctionVars.OpenAuctionSlots) if slotNum > closedAuctionSlots && slotNum <= (closedAuctionSlots+openAuctionSlots) { return true } return false } func (a *API) newSlotAPI(slotNum, currentBlockNum int64, bid *historydb.BidAPI, auctionVars *common.AuctionVariables) SlotAPI { firstBlock, lastBlock := a.getFirstLastBlock(slotNum) openAuction := a.isOpenAuction(currentBlockNum, slotNum, *auctionVars) slot := SlotAPI{ ItemID: uint64(slotNum), SlotNum: slotNum, FirstBlock: firstBlock, LastBlock: lastBlock, OpenAuction: openAuction, WinnerBid: bid, } return slot } func (a *API) newSlotsAPIFromWinnerBids(fromItem *uint, order string, bids []historydb.BidAPI, currentBlockNum int64, auctionVars *common.AuctionVariables) (slots []SlotAPI) { for i := range bids { slotNum := bids[i].SlotNum slot := a.newSlotAPI(slotNum, currentBlockNum, &bids[i], auctionVars) if order == historydb.OrderAsc { if slot.ItemID >= uint64(*fromItem) { slots = append(slots, slot) } } else { if slot.ItemID <= uint64(*fromItem) { slots = append(slots, slot) } } } return slots } func (a *API) addEmptySlot(slots []SlotAPI, slotNum int64, currentBlockNum int64, auctionVars *common.AuctionVariables, fromItem *uint, order string) ([]SlotAPI, error) { emptySlot := a.newSlotAPI(slotNum, currentBlockNum, nil, auctionVars) if order == historydb.OrderAsc { if emptySlot.ItemID >= uint64(*fromItem) { slots = append(slots, emptySlot) } } else { if emptySlot.ItemID <= uint64(*fromItem) { slots = append([]SlotAPI{emptySlot}, slots...) } } return slots, nil } func (a *API) getSlot(c *gin.Context) { slotNumUint, err := parseParamUint("slotNum", nil, 0, maxUint32, c) if err != nil { retBadReq(err, c) return } currentBlock, err := a.h.GetLastBlock() if err != nil { retBadReq(err, c) return } auctionVars, err := a.h.GetAuctionVars() if err != nil { retBadReq(err, c) return } slotNum := int64(*slotNumUint) bid, err := a.h.GetBestBidAPI(&slotNum) if err != nil && err != sql.ErrNoRows { retSQLErr(err, c) return } var slot SlotAPI if err == sql.ErrNoRows { slot = a.newSlotAPI(slotNum, currentBlock.EthBlockNum, nil, auctionVars) } else { slot = a.newSlotAPI(bid.SlotNum, currentBlock.EthBlockNum, &bid, auctionVars) } // JSON response c.JSON(http.StatusOK, slot) } func getLimits( minSlotNum, maxSlotNum int64, fromItem, limit *uint, order string, ) (minLimit, maxLimit int64, pendingItems uint64) { if order == historydb.OrderAsc { if fromItem != nil && int64(*fromItem) > minSlotNum { minLimit = int64(*fromItem) } else { minLimit = minSlotNum } if limit != nil && (minLimit+int64(*limit-1)) < maxSlotNum { maxLimit = minLimit + int64(*limit-1) } else { maxLimit = maxSlotNum } pendingItems = uint64(maxSlotNum - maxLimit) } else { if fromItem != nil && int64(*fromItem) < maxSlotNum { maxLimit = int64(*fromItem) } else { maxLimit = maxSlotNum } if limit != nil && (maxLimit-int64(*limit-1)) < minSlotNum { minLimit = minSlotNum } else { minLimit = maxLimit - int64(*limit-1) } pendingItems = uint64(-(minSlotNum - minLimit)) } return minLimit, maxLimit, pendingItems } func getLimitsWithAddr(minSlotNum, maxSlotNum *int64, fromItem, limit *uint, order string) (int64, int64) { var minLim, maxLim int64 if fromItem != nil { if order == historydb.OrderAsc { maxLim = *maxSlotNum if int64(*fromItem) > *minSlotNum { minLim = int64(*fromItem) } else { minLim = *minSlotNum } } else { minLim = *minSlotNum if int64(*fromItem) < *maxSlotNum { maxLim = int64(*fromItem) } else { maxLim = *maxSlotNum } } } return minLim, maxLim } func (a *API) getSlots(c *gin.Context) { var slots []SlotAPI minSlotNumDflt := int64(0) // Get filters minSlotNum, maxSlotNum, wonByEthereumAddress, finishedAuction, err := parseSlotFilters(c) if err != nil { retBadReq(err, c) return } // Pagination fromItem, order, limit, err := parsePagination(c) if err != nil { retBadReq(err, c) return } currentBlock, err := a.h.GetLastBlock() if err != nil { retBadReq(err, c) return } auctionVars, err := a.h.GetAuctionVars() if err != nil { retBadReq(err, c) return } // Check filters if maxSlotNum == nil && finishedAuction == nil { retBadReq(errors.New("It is necessary to add maxSlotNum filter"), c) return } else if finishedAuction != nil { if maxSlotNum == nil && !*finishedAuction { retBadReq(errors.New("It is necessary to add maxSlotNum filter"), c) return } else if *finishedAuction { currentBlock, err := a.h.GetLastBlock() if err != nil { retBadReq(err, c) return } currentSlot := a.getCurrentSlot(currentBlock.EthBlockNum) auctionVars, err := a.h.GetAuctionVars() if err != nil { retBadReq(err, c) return } closedAuctionSlots := currentSlot + int64(auctionVars.ClosedAuctionSlots) if maxSlotNum == nil { maxSlotNum = &closedAuctionSlots } else if closedAuctionSlots < *maxSlotNum { maxSlotNum = &closedAuctionSlots } } } else if maxSlotNum != nil && minSlotNum != nil { if *minSlotNum > *maxSlotNum { retBadReq(errors.New("It is necessary to add valid filter (minSlotNum <= maxSlotNum)"), c) return } } if minSlotNum == nil { minSlotNum = &minSlotNumDflt } // Get bids and pagination according to filters var slotMinLim, slotMaxLim int64 var bids []historydb.BidAPI var pendingItems uint64 if wonByEthereumAddress == nil { slotMinLim, slotMaxLim, pendingItems = getLimits(*minSlotNum, *maxSlotNum, fromItem, limit, order) // Get best bids in range maxSlotNum - minSlotNum bids, _, err = a.h.GetBestBidsAPI(&slotMinLim, &slotMaxLim, wonByEthereumAddress, nil, order) if err != nil && err != sql.ErrNoRows { retSQLErr(err, c) return } } else { slotMinLim, slotMaxLim = getLimitsWithAddr(minSlotNum, maxSlotNum, fromItem, limit, order) bids, pendingItems, err = a.h.GetBestBidsAPI(&slotMinLim, &slotMaxLim, wonByEthereumAddress, limit, order) if err != nil && err != sql.ErrNoRows { retSQLErr(err, c) return } } // Build the slot information with previous bids var slotsBids []SlotAPI if len(bids) > 0 { slotsBids = a.newSlotsAPIFromWinnerBids(fromItem, order, bids, currentBlock.EthBlockNum, auctionVars) if err != nil { retBadReq(err, c) return } } // Build the other slots if wonByEthereumAddress == nil { // Build hte information of the slots with bids or not for i := slotMinLim; i <= slotMaxLim; i++ { found := false for j := range slotsBids { if slotsBids[j].SlotNum == i { found = true if order == historydb.OrderAsc { if slotsBids[j].ItemID >= uint64(*fromItem) { slots = append(slots, slotsBids[j]) } } else { if slotsBids[j].ItemID <= uint64(*fromItem) { slots = append([]SlotAPI{slotsBids[j]}, slots...) } } break } } if !found { slots, err = a.addEmptySlot(slots, i, currentBlock.EthBlockNum, auctionVars, fromItem, order) if err != nil { retBadReq(err, c) return } } } } else if len(slotsBids) > 0 { slots = slotsBids } if len(slots) == 0 { retSQLErr(sql.ErrNoRows, c) return } // Build succesfull response type slotsResponse struct { Slots []SlotAPI `json:"slots"` PendingItems uint64 `json:"pendingItems"` } c.JSON(http.StatusOK, &slotsResponse{ Slots: slots, PendingItems: pendingItems, }) }