upsert functionality for dao coin limit orders in badger

lib/block_view_flush.go

@@ -1307,14 +1307,16 @@ func (bav *UtxoView) _flushDAOCoinLimitOrderEntriesToDbWithTxn(txn *badger.Txn,
 	glog.V(2).Infof("_flushDAOCoinLimitOrderEntriesToDbWithTxn: flushing %d mappings", len(bav.DAOCoinLimitOrderMapKeyToDAOCoinLimitOrderEntry))
 
 	// Go through all the entries in the DAOCoinLimitOrderMapKeyToDAOCoinLimitOrderEntry map.
+	numDeleted := 0
+	numPut := 0
 	for orderIter, orderEntry := range bav.DAOCoinLimitOrderMapKeyToDAOCoinLimitOrderEntry {
 		// Make a copy of the iterator since we take references to it below.
 		orderKey := orderIter
 
 		// Validate order map key matches order entry.
 		orderMapKey := orderEntry.ToMapKey()
 
-		if !reflect.DeepEqual(orderKey, orderMapKey) {
+		if !orderKey.Eq(orderMapKey) {
 			return fmt.Errorf("_flushDAOCoinLimitOrderEntriesToDbWithTxn: DAOCoinLimitOrderEntry has "+
 				"map key: %v which does not match match "+
 				"the DAOCoinLimitOrderMapKey map key %v",
@@ -1323,31 +1325,20 @@ func (bav *UtxoView) _flushDAOCoinLimitOrderEntriesToDbWithTxn(txn *badger.Txn,
 
 		// Delete the existing mappings in the db for this balance key. They will be re-added
 		// if the corresponding entry in memory has isDeleted=false.
-		if err := DBDeleteDAOCoinLimitOrderWithTxn(txn, bav.Snapshot, orderEntry, bav.EventManager, orderEntry.isDeleted); err != nil {
-			return errors.Wrapf(
-				err, "_flushDAOCoinLimitOrderEntriesToDbWithTxn: problem deleting mappings")
-		}
-	}
-
-	// Update logs with number of entries deleted and/ put.
-	numDeleted := 0
-	numPut := 0
-
-	// Go through all the entries in the DAOCoinLimitOrderMapKeyToDAOCoinLimitOrderEntry map.
-	for _, orderEntry := range bav.DAOCoinLimitOrderMapKeyToDAOCoinLimitOrderEntry {
-		// Make a copy of the iterator since we take references to it below.
 		if orderEntry.isDeleted {
 			numDeleted++
-			// If the OrderEntry has isDeleted=true then there's nothing to do because
-			// we already deleted the entry above.
+			if err := DBDeleteDAOCoinLimitOrderWithTxn(txn, bav.Snapshot, orderEntry, bav.EventManager, orderEntry.isDeleted); err != nil {
+				return errors.Wrapf(
+					err, "_flushDAOCoinLimitOrderEntriesToDbWithTxn: problem deleting mappings")
+			}
 		} else {
 			numPut++
-			// If the OrderEntry has (isDeleted = false) then we put the corresponding
-			// mappings for it into the db.
-			if err := DBPutDAOCoinLimitOrderWithTxn(txn, bav.Snapshot, orderEntry, blockHeight, bav.EventManager); err != nil {
-				return err
+			if err := DBUpsertDAOCoinLimitOrderWithTxn(txn, bav.Snapshot, orderEntry, blockHeight, bav.EventManager); err != nil {
+				return errors.Wrapf(
+					err, "_flushDAOCoinLimitOrderEntriesToDbWithTxn: problem putting mappings for order %v", orderEntry)
 			}
 		}
+
 	}
 
 	glog.V(2).Infof("_flushDAOCoinLimitOrderEntriesToDbWithTxn: deleted %d mappings, put %d mappings", numDeleted, numPut)

lib/block_view_types.go

@@ -6118,6 +6118,10 @@ func (order *DAOCoinLimitOrderEntry) ToMapKey() DAOCoinLimitOrderMapKey {
 	}
 }
 
+func (orderMapKey DAOCoinLimitOrderMapKey) Eq(otherOrderMapKey DAOCoinLimitOrderMapKey) bool {
+	return orderMapKey.OrderID.IsEqual(&otherOrderMapKey.OrderID)
+}
+
 func (order *FilledDAOCoinLimitOrder) RawEncodeWithoutMetadata(blockHeight uint64, skipMetadata ...bool) []byte {
 	var data []byte
 

lib/db_utils.go

@@ -10320,6 +10320,54 @@ func DBPutDAOCoinLimitOrderWithTxn(txn *badger.Txn, snap *Snapshot, order *DAOCo
 	return nil
 }
 
+func DBUpsertDAOCoinLimitOrderWithTxn(
+	txn *badger.Txn,
+	snap *Snapshot,
+	order *DAOCoinLimitOrderEntry,
+	blockHeight uint64,
+	eventManager *EventManager,
+) error {
+	if order == nil {
+		return nil
+	}
+
+	orderBytes := EncodeToBytes(blockHeight, order)
+	// Store in index: PrefixDAOCoinLimitOrderByTransactorPKID
+	key := DBKeyForDAOCoinLimitOrder(order)
+
+	currBytes, err := DBGetWithTxn(txn, snap, key)
+	if err != nil {
+		if !errors.Is(err, badger.ErrKeyNotFound) {
+			return errors.Wrapf(err, "DBUpsertDAOCoinLimitOrderWithTxn: problem getting limit order")
+		}
+	} else {
+		// If the order already exists, we need to compare the bytes.
+		// If the bytes are the same, we don't need to update.
+		if bytes.Equal(currBytes, orderBytes) {
+			// No need to update if the bytes are the same.
+			return nil
+		}
+	}
+
+	if err = DBSetWithTxn(txn, snap, key, orderBytes, eventManager); err != nil {
+		return errors.Wrapf(err, "DBUpsertDAOCoinLimitOrderWithTxn: problem storing limit order")
+	}
+
+	// Store in index: PrefixDAOCoinLimitOrderByTransactorPKID
+	key = DBKeyForDAOCoinLimitOrderByTransactorPKID(order)
+	if err = DBSetWithTxn(txn, snap, key, orderBytes, eventManager); err != nil {
+		return errors.Wrapf(err, "DBUpsertDAOCoinLimitOrderWithTxn: problem storing limit order")
+	}
+
+	// Store in index: PrefixDAOCoinLimitOrderByOrderID
+	key = DBKeyForDAOCoinLimitOrderByOrderID(order)
+	if err = DBSetWithTxn(txn, snap, key, orderBytes, eventManager); err != nil {
+		return errors.Wrapf(err, "DBUpsertDAOCoinLimitOrderWithTxn: problem storing order in index PrefixDAOCoinLimitOrderByOrderID")
+	}
+
+	return nil
+}
+
 func DBDeleteDAOCoinLimitOrderWithTxn(txn *badger.Txn, snap *Snapshot, order *DAOCoinLimitOrderEntry, eventManager *EventManager, entryIsDeleted bool) error {
 	if order == nil {
 		return nil