Core/PacketIO: Add new auction house packet structures (not used yet)

11 files changed, 986 insertions, 377 deletions

diff --git a/src/server/game/AuctionHouse/AuctionHouseMgr.cpp b/src/server/game/AuctionHouse/AuctionHouseMgr.cpp
index a856d3c4d71..1a3eb5ecd49 100644
--- a/src/server/game/AuctionHouse/AuctionHouseMgr.cpp
+++ b/src/server/game/AuctionHouse/AuctionHouseMgr.cpp
@@ -516,7 +516,7 @@ void AuctionHouseMgr::UpdatePendingAuctions()
             {
                 AuctionEntry* AH = (*AHitr);
                 ++AHitr;
-                AH->expire_time = time(NULL);
+                AH->expire_time = time(nullptr);
                 AH->DeleteFromDB(trans);
                 AH->SaveToDB(trans);
             }
@@ -655,34 +655,29 @@ void AuctionHouseObject::Update()
     CharacterDatabase.CommitTransaction(trans);
 }
 
-void AuctionHouseObject::BuildListBidderItems(WorldPackets::AuctionHouse::AuctionListBidderItemsResult& packet, Player* player, uint32& totalcount)
+void AuctionHouseObject::BuildListBidderItems(WorldPackets::AuctionHouse::AuctionListBidderItemsResult& packet, Player* player)
 {
     for (AuctionEntryMap::const_iterator itr = AuctionsMap.begin(); itr != AuctionsMap.end(); ++itr)
     {
         AuctionEntry* Aentry = itr->second;
         if (Aentry && Aentry->bidder == player->GetGUID().GetCounter())
-        {
             itr->second->BuildAuctionInfo(packet.Items, false);
-            ++totalcount;
-        }
     }
 }
 
-void AuctionHouseObject::BuildListOwnerItems(WorldPackets::AuctionHouse::AuctionListOwnerItemsResult& packet, Player* player, uint32& totalcount)
+void AuctionHouseObject::BuildListOwnerItems(WorldPackets::AuctionHouse::AuctionListOwnerItemsResult& packet, Player* player)
 {
     for (AuctionEntryMap::const_iterator itr = AuctionsMap.begin(); itr != AuctionsMap.end(); ++itr)
     {
         AuctionEntry* Aentry = itr->second;
         if (Aentry && Aentry->owner == player->GetGUID().GetCounter())
-        {
             Aentry->BuildAuctionInfo(packet.Items, false);
-            ++totalcount;
-        }
     }
 }
 
 void AuctionHouseObject::BuildListAuctionItems(WorldPackets::AuctionHouse::AuctionListItemsResult& packet, Player* player,
-    std::wstring const& searchedname, uint32 listfrom, uint8 levelmin, uint8 levelmax, bool usable, Optional<AuctionSearchFilters> const& filters, uint32 quality)
+    std::wstring const& searchedname, uint32 listfrom, uint8 levelmin, uint8 levelmax, EnumClassFlag<AuctionHouseFilterMask> filters,
+    Optional<AuctionSearchClassFilters> const& classFilters)
 {
     time_t curTime = GameTime::GetGameTime();
 
@@ -698,32 +693,32 @@ void AuctionHouseObject::BuildListAuctionItems(WorldPackets::AuctionHouse::Aucti
             continue;
 
         ItemTemplate const* proto = item->GetTemplate();
-        if (filters)
+        if (classFilters)
         {
             // if we dont want any class filters, Optional is not initialized
             // if we dont want this class included, SubclassMask is set to FILTER_SKIP_CLASS
             // if we want this class and did not specify and subclasses, its set to FILTER_SKIP_SUBCLASS
             // otherwise full restrictions apply
-            if (filters->Classes[proto->GetClass()].SubclassMask == AuctionSearchFilters::FILTER_SKIP_CLASS)
+            if (classFilters->Classes[proto->GetClass()].SubclassMask == AuctionSearchClassFilters::FILTER_SKIP_CLASS)
                 continue;
 
-            if (filters->Classes[proto->GetClass()].SubclassMask != AuctionSearchFilters::FILTER_SKIP_SUBCLASS)
+            if (classFilters->Classes[proto->GetClass()].SubclassMask != AuctionSearchClassFilters::FILTER_SKIP_SUBCLASS)
             {
-                if (!(filters->Classes[proto->GetClass()].SubclassMask & (1 << proto->GetSubClass())))
+                if (!(classFilters->Classes[proto->GetClass()].SubclassMask & (1 << proto->GetSubClass())))
                     continue;
 
-                if (!(filters->Classes[proto->GetClass()].InvTypes[proto->GetSubClass()] & (1 << proto->GetInventoryType())))
+                if (!(classFilters->Classes[proto->GetClass()].InvTypes[proto->GetSubClass()] & (1 << proto->GetInventoryType())))
                     continue;
             }
         }
 
-        if (quality != 0xffffffff && proto->GetQuality() != quality)
+        if (!filters.HasFlag(static_cast<AuctionHouseFilterMask>(1 << (proto->GetQuality() + 4))))
             continue;
 
         if (levelmin != 0 && (item->GetRequiredLevel() < levelmin || (levelmax != 0 && item->GetRequiredLevel() > levelmax)))
             continue;
 
-        if (usable && player->CanUseItem(item) != EQUIP_ERR_OK)
+        if (filters.HasFlag(AuctionHouseFilterMask::UsableOnly) && player->CanUseItem(item) != EQUIP_ERR_OK)
             continue;
 
         // Allow search by suffix (ie: of the Monkey) or partial name (ie: Monkey)
@@ -790,7 +785,7 @@ void AuctionHouseObject::BuildReplicate(WorldPackets::AuctionHouse::AuctionRepli
     }
 
     auctionReplicateResult.ChangeNumberGlobal = throttleItr->second.Global;
-    auctionReplicateResult.ChangeNumberCursor = throttleItr->second.Cursor = !auctionReplicateResult.Items.empty() ? auctionReplicateResult.Items.back().AuctionItemID : 0;
+    auctionReplicateResult.ChangeNumberCursor = throttleItr->second.Cursor = !auctionReplicateResult.Items.empty() ? auctionReplicateResult.Items.back().AuctionID : 0;
     auctionReplicateResult.ChangeNumberTombstone = throttleItr->second.Tombstone = !count ? AuctionsMap.rbegin()->first : 0;
 }
 
@@ -806,15 +801,16 @@ void AuctionEntry::BuildAuctionInfo(std::vector<WorldPackets::AuctionHouse::Auct
 
     WorldPackets::AuctionHouse::AuctionItem auctionItem;
 
-    auctionItem.AuctionItemID = Id;
-    auctionItem.Item.Initialize(item);
+    auctionItem.AuctionID = Id;
+    auctionItem.Item.emplace();
+    auctionItem.Item->Initialize(item);
     auctionItem.BuyoutPrice = buyout;
     auctionItem.CensorBidInfo = false;
     auctionItem.CensorServerSideInfo = listAuctionItems;
     auctionItem.Charges = item->GetSpellCharges();
     auctionItem.Count = item->GetCount();
     auctionItem.DeleteReason = 0; // Always 0 ?
-    auctionItem.DurationLeft = (expire_time - time(NULL)) * IN_MILLISECONDS;
+    auctionItem.DurationLeft = (expire_time - time(nullptr)) * IN_MILLISECONDS;
     auctionItem.EndTime = expire_time;
     auctionItem.Flags = 0; // todo
     auctionItem.ItemGuid = item->GetGUID();
diff --git a/src/server/game/AuctionHouse/AuctionHouseMgr.h b/src/server/game/AuctionHouse/AuctionHouseMgr.h
index a53568bce5e..49d8dbebef8 100644
--- a/src/server/game/AuctionHouse/AuctionHouseMgr.h
+++ b/src/server/game/AuctionHouse/AuctionHouseMgr.h
@@ -20,6 +20,7 @@
 
 #include "Define.h"
 #include "DatabaseEnvFwd.h"
+#include "EnumClassFlag.h"
 #include "ItemTemplate.h"
 #include "ObjectGuid.h"
 #include "Optional.h"
@@ -47,15 +48,20 @@ namespace WorldPackets
 
 enum AuctionError
 {
-    ERR_AUCTION_OK                  = 0,
-    ERR_AUCTION_INVENTORY           = 1,
-    ERR_AUCTION_DATABASE_ERROR      = 2,
-    ERR_AUCTION_NOT_ENOUGHT_MONEY   = 3,
-    ERR_AUCTION_ITEM_NOT_FOUND      = 4,
-    ERR_AUCTION_HIGHER_BID          = 5,
-    ERR_AUCTION_BID_INCREMENT       = 7,
-    ERR_AUCTION_BID_OWN             = 10,
-    ERR_AUCTION_RESTRICTED_ACCOUNT  = 13
+    ERR_AUCTION_OK                          = 0,
+    ERR_AUCTION_INVENTORY                   = 1,
+    ERR_AUCTION_DATABASE_ERROR              = 2,
+    ERR_AUCTION_NOT_ENOUGH_MONEY            = 3,
+    ERR_AUCTION_ITEM_NOT_FOUND              = 4,
+    ERR_AUCTION_HIGHER_BID                  = 5,
+    ERR_AUCTION_BID_INCREMENT               = 7,
+    ERR_AUCTION_BID_OWN                     = 10,
+    ERR_AUCTION_RESTRICTED_ACCOUNT_TRIAL    = 13,
+    ERR_AUCTION_HAS_RESTRICTION             = 17,
+    ERR_AUCTION_HOUSE_BUSY                  = 18,
+    ERR_AUCTION_HOUSE_UNAVAILABLE           = 19,
+    ERR_AUCTION_COMMODITY_PURCHASE_FAILED   = 21,
+    ERR_AUCTION_ITEM_HAS_QUOTE              = 23
 };
 
 enum AuctionAction
@@ -76,6 +82,42 @@ enum MailAuctionAnswers
     AUCTION_SALE_PENDING        = 6
 };
 
+enum class AuctionHouseFilterMask : uint32
+{
+    UncollectedOnly     = 0x1,
+    UsableOnly          = 0x2,
+    UpgradesOnly        = 0x4,
+    ExactMatch          = 0x8,
+    PoorQuality         = 0x10,
+    CommonQuality       = 0x20,
+    UncommonQuality     = 0x40,
+    RareQuality         = 0x80,
+    EpicQuality         = 0x100,
+    LegendaryQuality    = 0x200,
+    ArtifactQuality     = 0x400,
+};
+
+enum class AuctionHouseSortOrder : uint8
+{
+    Price   = 0,
+    Name    = 1,
+    Level   = 2,
+    Bid     = 3,
+    Buyout  = 4
+};
+
+enum class AuctionHouseBrowseMode : uint8
+{
+    Search          = 0,
+    SpecificKeys    = 1
+};
+
+enum class AuctionHouseListType : uint8
+{
+    Commodities = 1,
+    Items       = 2
+};
+
 struct TC_GAME_API AuctionEntry
 {
     uint32 Id;
@@ -109,7 +151,7 @@ struct TC_GAME_API AuctionEntry
 
 };
 
-struct AuctionSearchFilters
+struct AuctionSearchClassFilters
 {
     enum FilterType : uint32
     {
@@ -168,10 +210,11 @@ class TC_GAME_API AuctionHouseObject
 
     void Update();
 
-    void BuildListBidderItems(WorldPackets::AuctionHouse::AuctionListBidderItemsResult& packet, Player* player, uint32& totalcount);
-    void BuildListOwnerItems(WorldPackets::AuctionHouse::AuctionListOwnerItemsResult& packet, Player* player, uint32& totalcount);
+    void BuildListBidderItems(WorldPackets::AuctionHouse::AuctionListBidderItemsResult& packet, Player* player);
+    void BuildListOwnerItems(WorldPackets::AuctionHouse::AuctionListOwnerItemsResult& packet, Player* player);
     void BuildListAuctionItems(WorldPackets::AuctionHouse::AuctionListItemsResult& packet, Player* player,
-        std::wstring const& searchedname, uint32 listfrom, uint8 levelmin, uint8 levelmax, bool usable, Optional<AuctionSearchFilters> const& filters, uint32 quality);
+        std::wstring const& searchedname, uint32 listfrom, uint8 levelmin, uint8 levelmax, EnumClassFlag<AuctionHouseFilterMask> filters,
+        Optional<AuctionSearchClassFilters> const& classFilters);
     void BuildReplicate(WorldPackets::AuctionHouse::AuctionReplicateResponse& auctionReplicateResult, Player* player,
         uint32 global, uint32 cursor, uint32 tombstone, uint32 count);
 
diff --git a/src/server/game/Handlers/AuctionHouseHandler.cpp b/src/server/game/Handlers/AuctionHouseHandler.cpp
index 87c0e29b43f..a86c5acd72c 100644
--- a/src/server/game/Handlers/AuctionHouseHandler.cpp
+++ b/src/server/game/Handlers/AuctionHouseHandler.cpp
@@ -80,7 +80,7 @@ void WorldSession::SendAuctionCommandResult(AuctionEntry* auction, uint32 action
 
 void WorldSession::SendAuctionOutBidNotification(AuctionEntry const* auction, Item const* item)
 {
-    WorldPackets::AuctionHouse::AuctionOutBidNotification packet;
+    WorldPackets::AuctionHouse::AuctionOutbidNotification packet;
     packet.BidAmount = auction->bid;
     packet.MinIncrement = auction->GetAuctionOutBid();
     packet.Info.Initialize(auction, item);
@@ -231,7 +231,7 @@ void WorldSession::HandleAuctionSellItem(WorldPackets::AuctionHouse::AuctionSell
     uint64 deposit = sAuctionMgr->GetAuctionDeposit(auctionHouseEntry, packet.RunTime, item, finalCount);
     if (!_player->HasEnoughMoney(deposit))
     {
-        SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_NOT_ENOUGHT_MONEY);
+        SendAuctionCommandResult(NULL, AUCTION_SELL_ITEM, ERR_AUCTION_NOT_ENOUGH_MONEY);
         return;
     }
 
@@ -271,7 +271,7 @@ void WorldSession::HandleAuctionSellItem(WorldPackets::AuctionHouse::AuctionSell
         // Add to pending auctions, or fail with insufficient funds error
         if (!sAuctionMgr->PendingAuctionAdd(_player, AH, item))
         {
-            SendAuctionCommandResult(AH, AUCTION_SELL_ITEM, ERR_AUCTION_NOT_ENOUGHT_MONEY);
+            SendAuctionCommandResult(AH, AUCTION_SELL_ITEM, ERR_AUCTION_NOT_ENOUGH_MONEY);
             return;
         }
 
@@ -328,7 +328,7 @@ void WorldSession::HandleAuctionSellItem(WorldPackets::AuctionHouse::AuctionSell
         // Add to pending auctions, or fail with insufficient funds error
         if (!sAuctionMgr->PendingAuctionAdd(_player, AH, newItem))
         {
-            SendAuctionCommandResult(AH, AUCTION_SELL_ITEM, ERR_AUCTION_NOT_ENOUGHT_MONEY);
+            SendAuctionCommandResult(AH, AUCTION_SELL_ITEM, ERR_AUCTION_NOT_ENOUGH_MONEY);
             return;
         }
 
@@ -378,7 +378,7 @@ void WorldSession::HandleAuctionSellItem(WorldPackets::AuctionHouse::AuctionSell
 // this function is called when client bids or buys out auction
 void WorldSession::HandleAuctionPlaceBid(WorldPackets::AuctionHouse::AuctionPlaceBid& packet)
 {
-    if (!packet.AuctionItemID || !packet.BidAmount)
+    if (!packet.AuctionID || !packet.BidAmount)
         return; // check for cheaters
 
     Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.Auctioneer, UNIT_NPC_FLAG_AUCTIONEER, UNIT_NPC_FLAG_2_NONE);
@@ -394,7 +394,7 @@ void WorldSession::HandleAuctionPlaceBid(WorldPackets::AuctionHouse::AuctionPlac
 
     AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
 
-    AuctionEntry* auction = auctionHouse->GetAuction(packet.AuctionItemID);
+    AuctionEntry* auction = auctionHouse->GetAuction(packet.AuctionID);
     Player* player = GetPlayer();
 
     if (!auction || auction->owner == player->GetGUID().GetCounter())
@@ -430,7 +430,7 @@ void WorldSession::HandleAuctionPlaceBid(WorldPackets::AuctionHouse::AuctionPlac
     if (!player->HasEnoughMoney(packet.BidAmount))
     {
         // client already test it but just in case ...
-        SendAuctionCommandResult(auction, AUCTION_PLACE_BID, ERR_AUCTION_NOT_ENOUGHT_MONEY);
+        SendAuctionCommandResult(auction, AUCTION_PLACE_BID, ERR_AUCTION_NOT_ENOUGH_MONEY);
         return;
     }
 
@@ -518,7 +518,7 @@ void WorldSession::HandleAuctionRemoveItem(WorldPackets::AuctionHouse::AuctionRe
 
     AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
 
-    AuctionEntry* auction = auctionHouse->GetAuction(packet.AuctionItemID);
+    AuctionEntry* auction = auctionHouse->GetAuction(packet.AuctionID);
     Player* player = GetPlayer();
 
     CharacterDatabaseTransaction trans = CharacterDatabase.BeginTransaction();
@@ -552,7 +552,7 @@ void WorldSession::HandleAuctionRemoveItem(WorldPackets::AuctionHouse::AuctionRe
     {
         SendAuctionCommandResult(NULL, AUCTION_CANCEL, ERR_AUCTION_DATABASE_ERROR);
         //this code isn't possible ... maybe there should be assert
-        TC_LOG_ERROR("entities.player.cheat", "CHEATER: %s tried to cancel auction (id: %u) of another player or auction is NULL", player->GetGUID().ToString().c_str(), packet.AuctionItemID);
+        TC_LOG_ERROR("entities.player.cheat", "CHEATER: %s tried to cancel auction (id: %u) of another player or auction is NULL", player->GetGUID().ToString().c_str(), packet.AuctionID);
         return;
     }
 
@@ -588,7 +588,7 @@ void WorldSession::HandleAuctionListBidderItems(WorldPackets::AuctionHouse::Auct
     WorldPackets::AuctionHouse::AuctionListBidderItemsResult result;
 
     Player* player = GetPlayer();
-    auctionHouse->BuildListBidderItems(result, player, result.TotalCount);
+    auctionHouse->BuildListBidderItems(result, player);
     result.DesiredDelay = 300;
     SendPacket(result.Write());
 }
@@ -611,18 +611,18 @@ void WorldSession::HandleAuctionListOwnerItems(WorldPackets::AuctionHouse::Aucti
 
     WorldPackets::AuctionHouse::AuctionListOwnerItemsResult result;
 
-    auctionHouse->BuildListOwnerItems(result, _player, result.TotalCount);
+    auctionHouse->BuildListOwnerItems(result, _player);
     result.DesiredDelay = 300;
     SendPacket(result.Write());
 }
 
 //this void is called when player clicks on search button
-void WorldSession::HandleAuctionListItems(WorldPackets::AuctionHouse::AuctionListItems& packet)
+void WorldSession::HandleAuctionListItems(WorldPackets::AuctionHouse::AuctionBrowseQuery& browseQuery)
 {
-    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(packet.Auctioneer, UNIT_NPC_FLAG_AUCTIONEER, UNIT_NPC_FLAG_2_NONE);
+    Creature* creature = GetPlayer()->GetNPCIfCanInteractWith(browseQuery.Auctioneer, UNIT_NPC_FLAG_AUCTIONEER, UNIT_NPC_FLAG_2_NONE);
     if (!creature)
     {
-        TC_LOG_DEBUG("network", "WORLD: HandleAuctionListItems - %s not found or you can't interact with him.", packet.Auctioneer.ToString().c_str());
+        TC_LOG_DEBUG("network", "WORLD: HandleAuctionListItems - %s not found or you can't interact with him.", browseQuery.Auctioneer.ToString().c_str());
         return;
     }
 
@@ -632,24 +632,24 @@ void WorldSession::HandleAuctionListItems(WorldPackets::AuctionHouse::AuctionLis
 
     AuctionHouseObject* auctionHouse = sAuctionMgr->GetAuctionsMap(creature->getFaction());
 
-    TC_LOG_DEBUG("auctionHouse", "Auctionhouse search (%s), searchedname: %s, levelmin: %u, levelmax: %u, quality: %u, usable: %u",
-        packet.Auctioneer.ToString().c_str(), packet.Name.c_str(), packet.MinLevel, packet.MaxLevel , packet.Quality, packet.OnlyUsable);
+    TC_LOG_DEBUG("auctionHouse", "Auctionhouse search (%s), searchedname: %s, levelmin: %u, levelmax: %u, filters: %u",
+        browseQuery.Auctioneer.ToString().c_str(), browseQuery.Name.c_str(), browseQuery.MinLevel, browseQuery.MaxLevel , browseQuery.Filters);
 
     // converting string that we try to find to lower case
     std::wstring wsearchedname;
-    if (!Utf8toWStr(packet.Name, wsearchedname))
+    if (!Utf8toWStr(browseQuery.Name, wsearchedname))
         return;
 
     wstrToLower(wsearchedname);
 
-    Optional<AuctionSearchFilters> filters;
+    Optional<AuctionSearchClassFilters> classFilters;
 
     WorldPackets::AuctionHouse::AuctionListItemsResult result;
-    if (!packet.ClassFilters.empty())
+    if (!browseQuery.ItemClassFilters.empty())
     {
-        filters = boost::in_place();
+        classFilters = boost::in_place();
 
-        for (auto const& classFilter : packet.ClassFilters)
+        for (auto const& classFilter : browseQuery.ItemClassFilters)
         {
             if (!classFilter.SubClassFilters.empty())
             {
@@ -657,28 +657,21 @@ void WorldSession::HandleAuctionListItems(WorldPackets::AuctionHouse::AuctionLis
                 {
                     if (classFilter.ItemClass < MAX_ITEM_CLASS)
                     {
-                        filters->Classes[classFilter.ItemClass].SubclassMask |= 1 << subClassFilter.ItemSubclass;
+                        classFilters->Classes[classFilter.ItemClass].SubclassMask |= 1 << subClassFilter.ItemSubclass;
                         if (subClassFilter.ItemSubclass < MAX_ITEM_SUBCLASS_TOTAL)
-                            filters->Classes[classFilter.ItemClass].InvTypes[subClassFilter.ItemSubclass] = subClassFilter.InvTypeMask;
+                            classFilters->Classes[classFilter.ItemClass].InvTypes[subClassFilter.ItemSubclass] = subClassFilter.InvTypeMask;
                     }
                 }
             }
             else
-                filters->Classes[classFilter.ItemClass].SubclassMask = AuctionSearchFilters::FILTER_SKIP_SUBCLASS;
+                classFilters->Classes[classFilter.ItemClass].SubclassMask = AuctionSearchClassFilters::FILTER_SKIP_SUBCLASS;
         }
     }
 
-    auctionHouse->BuildListAuctionItems(result, _player, wsearchedname, packet.Offset, packet.MinLevel, packet.MaxLevel, packet.OnlyUsable, filters, packet.Quality);
+    auctionHouse->BuildListAuctionItems(result, _player, wsearchedname, browseQuery.Offset, browseQuery.MinLevel, browseQuery.MaxLevel,
+        static_cast<AuctionHouseFilterMask>(browseQuery.Filters), classFilters);
 
     result.DesiredDelay = sWorld->getIntConfig(CONFIG_AUCTION_SEARCH_DELAY);
-    result.OnlyUsable = packet.OnlyUsable;
-    SendPacket(result.Write());
-}
-
-void WorldSession::HandleAuctionListPendingSales(WorldPackets::AuctionHouse::AuctionListPendingSales& /*packet*/)
-{
-    WorldPackets::AuctionHouse::AuctionListPendingSalesResult result;
-    result.TotalNumRecords = 0;
     SendPacket(result.Write());
 }
 
diff --git a/src/server/game/Server/Packets/AddonPackets.cpp b/src/server/game/Server/Packets/AddonPackets.cpp
new file mode 100644
index 00000000000..0fbe5f13669
--- /dev/null
+++ b/src/server/game/Server/Packets/AddonPackets.cpp
@@ -0,0 +1,39 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "AddonPackets.h"
+#include "ByteBuffer.h"
+
+ByteBuffer& WorldPackets::Addon::operator>>(ByteBuffer& data, AddOnInfo& addonInfo)
+{
+    uint32 nameLength = data.ReadBits(10);
+    uint32 versionLength = data.ReadBits(10);
+    addonInfo.Loaded = data.ReadBit();
+    addonInfo.Enabled = data.ReadBit();
+    if (nameLength > 1)
+    {
+        addonInfo.Name = data.ReadString(nameLength - 1);
+        data.read_skip<uint8>(); // null terminator
+    }
+    if (versionLength > 1)
+    {
+        addonInfo.Version = data.ReadString(versionLength - 1);
+        data.read_skip<uint8>(); // null terminator
+    }
+
+    return data;
+}
diff --git a/src/server/game/Server/Packets/AddonPackets.h b/src/server/game/Server/Packets/AddonPackets.h
new file mode 100644
index 00000000000..3b8faab79c2
--- /dev/null
+++ b/src/server/game/Server/Packets/AddonPackets.h
@@ -0,0 +1,41 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef AddonPackets_h__
+#define AddonPackets_h__
+
+#include <string>
+
+class ByteBuffer;
+
+namespace WorldPackets
+{
+    namespace Addon
+    {
+        struct AddOnInfo
+        {
+            std::string Name;
+            std::string Version;
+            bool Loaded = false;
+            bool Enabled = false;
+        };
+
+        ByteBuffer& operator>>(ByteBuffer& data, AddOnInfo& addonInfo);
+    }
+}
+
+#endif // AddonPackets_h__
diff --git a/src/server/game/Server/Packets/AllPackets.h b/src/server/game/Server/Packets/AllPackets.h
index db25482b00c..e095cd30f6a 100644
--- a/src/server/game/Server/Packets/AllPackets.h
+++ b/src/server/game/Server/Packets/AllPackets.h
@@ -19,6 +19,7 @@
 #define AllPackets_h__
 
 #include "AchievementPackets.h"
+#include "AddonPackets.h"
 #include "AreaTriggerPackets.h"
 #include "ArtifactPackets.h"
 #include "AuctionHousePackets.h"
diff --git a/src/server/game/Server/Packets/AuctionHousePackets.cpp b/src/server/game/Server/Packets/AuctionHousePackets.cpp
index 3fec801eecd..e88108f8091 100644
--- a/src/server/game/Server/Packets/AuctionHousePackets.cpp
+++ b/src/server/game/Server/Packets/AuctionHousePackets.cpp
@@ -18,33 +18,197 @@
 #include "AuctionHousePackets.h"
 #include "AuctionHouseMgr.h"
 #include "ObjectGuid.h"
-#include "MailPackets.h"
 
-ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::AuctionHouse::AuctionItem const& auctionItem)
+namespace WorldPackets
 {
-    data << auctionItem.Item; // ItemInstance
-    data << int32(auctionItem.Count);
-    data << int32(auctionItem.Charges);
-    data << int32(auctionItem.Flags);
-    data << int32(auctionItem.AuctionItemID);
-    data << auctionItem.Owner;
-    data << uint64(auctionItem.MinBid);
-    data << uint64(auctionItem.MinIncrement);
-    data << uint64(auctionItem.BuyoutPrice);
-    data << int32(auctionItem.DurationLeft);
-    data << uint8(auctionItem.DeleteReason);
+namespace AuctionHouse
+{
+ByteBuffer& operator>>(ByteBuffer& data, AuctionBucketKey& itemKey)
+{
+    data.ResetBitPos();
+    itemKey.ItemID = data.ReadBits(20);
+
+    if (data.ReadBit())
+        itemKey.BattlePetSpeciesID.emplace();
+
+    itemKey.ItemLevel = data.ReadBits(11);
+
+    if (data.ReadBit())
+        itemKey.SuffixItemNameDescriptionID.emplace();
+
+    if (itemKey.BattlePetSpeciesID)
+        data >> *itemKey.BattlePetSpeciesID;
+
+    if (itemKey.SuffixItemNameDescriptionID)
+        data >> *itemKey.SuffixItemNameDescriptionID;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, AuctionBucketKey const& itemKey)
+{
+    data.WriteBits(itemKey.ItemID, 20);
+    data.WriteBit(itemKey.BattlePetSpeciesID.is_initialized());
+    data.WriteBits(itemKey.ItemLevel, 11);
+    data.WriteBit(itemKey.SuffixItemNameDescriptionID.is_initialized());
+    data.FlushBits();
+
+    if (itemKey.BattlePetSpeciesID)
+        data << uint16(*itemKey.BattlePetSpeciesID);
+
+    if (itemKey.SuffixItemNameDescriptionID)
+        data << uint16(*itemKey.SuffixItemNameDescriptionID);
+
+    return data;
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, AuctionListFilterSubClass& filterSubClass)
+{
+    data >> filterSubClass.ItemSubclass;
+    data >> filterSubClass.InvTypeMask;
+
+    return data;
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, AuctionListFilterClass& filterClass)
+{
+    data >> filterClass.ItemClass;
+    filterClass.SubClassFilters.resize(data.ReadBits(5));
+    for (AuctionListFilterSubClass& filterSubClass : filterClass.SubClassFilters)
+        data >> filterSubClass;
+
+    return data;
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, AuctionSortDef& sortDef)
+{
+    data.ResetBitPos();
+    sortDef.SortOrder = static_cast<AuctionHouseSortOrder>(data.ReadBits(4));
+    sortDef.ReverseSort = data.ReadBit();
+
+    return data;
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, AuctionItemForSale& auctionItemForSale)
+{
+    data >> auctionItemForSale.Guid;
+    data >> auctionItemForSale.UseCount;
+
+    return data;
+}
+
+ByteBuffer& operator>>(ByteBuffer& data, AuctionFavoriteInfo& favoriteInfo)
+{
+    data >> favoriteInfo.Order;
+    data >> favoriteInfo.ItemID;
+    data >> favoriteInfo.ItemLevel;
+    data >> favoriteInfo.BattlePetSpeciesID;
+    data >> favoriteInfo.ItemSuffix;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, AuctionFavoriteInfo const& favoriteInfo)
+{
+    data << uint32(favoriteInfo.Order);
+    data << uint32(favoriteInfo.ItemID);
+    data << uint32(favoriteInfo.ItemLevel);
+    data << uint32(favoriteInfo.BattlePetSpeciesID);
+    data << uint32(favoriteInfo.ItemSuffix);
+
+    return data;
+}
+
+void AuctionOwnerNotification::Initialize(::AuctionEntry const* auction, ::Item const* item)
+{
+    AuctionID = auction->Id;
+    Item.Initialize(item);
+    BidAmount = auction->bid;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, AuctionOwnerNotification const& ownerNotification)
+{
+    data << int32(ownerNotification.AuctionID);
+    data << uint64(ownerNotification.BidAmount);
+    data << ownerNotification.Item;
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, BucketInfo const& bucketInfo)
+{
+    data << bucketInfo.Key;
+    data << int32(bucketInfo.TotalQuantity);
+    data << uint64(bucketInfo.MinPrice);
+    data << uint32(bucketInfo.ItemModifiedAppearanceIDs.size());
+    if (!bucketInfo.ItemModifiedAppearanceIDs.empty())
+        data.append(bucketInfo.ItemModifiedAppearanceIDs.data(), bucketInfo.ItemModifiedAppearanceIDs.size());
+
+    data.WriteBit(bucketInfo.MaxBattlePetQuality.is_initialized());
+    data.WriteBit(bucketInfo.MaxBattlePetLevel.is_initialized());
+    data.WriteBit(bucketInfo.BattlePetBreedID.is_initialized());
+    data.WriteBit(bucketInfo.ContainsOwnerItem);
+    data.WriteBit(bucketInfo.ContainsOnlyCollectedAppearances);
+    data.FlushBits();
+
+    if (bucketInfo.MaxBattlePetQuality)
+        data << uint8(*bucketInfo.MaxBattlePetQuality);
+
+    if (bucketInfo.MaxBattlePetLevel)
+        data << uint8(*bucketInfo.MaxBattlePetLevel);
+
+    if (bucketInfo.BattlePetBreedID)
+        data << uint8(*bucketInfo.BattlePetBreedID);
+
+    return data;
+}
+
+ByteBuffer& operator<<(ByteBuffer& data, AuctionItem const& auctionItem)
+{
+    data.WriteBit(auctionItem.Item.is_initialized());
     data.WriteBits(auctionItem.Enchantments.size(), 4);
     data.WriteBits(auctionItem.Gems.size(), 2);
+    data.WriteBit(auctionItem.MinBid.is_initialized());
+    data.WriteBit(auctionItem.MinIncrement.is_initialized());
+    data.WriteBit(auctionItem.BuyoutPrice.is_initialized());
+    data.WriteBit(auctionItem.UnitPrice.is_initialized());
     data.WriteBit(auctionItem.CensorServerSideInfo);
     data.WriteBit(auctionItem.CensorBidInfo);
+    data.WriteBit(auctionItem.AuctionBucketKey.is_initialized());
+    if (!auctionItem.CensorBidInfo)
+    {
+        data.WriteBit(auctionItem.Bidder.is_initialized());
+        data.WriteBit(auctionItem.BidAmount.is_initialized());
+    }
+
     data.FlushBits();
 
-    for (WorldPackets::Item::ItemGemData const& gem : auctionItem.Gems)
-        data << gem;
+    if (auctionItem.Item)
+        data << *auctionItem.Item;
+
+    data << int32(auctionItem.Count);
+    data << int32(auctionItem.Charges);
+    data << int32(auctionItem.Flags);
+    data << int32(auctionItem.AuctionID);
+    data << auctionItem.Owner;
+    data << int32(auctionItem.DurationLeft);
+    data << uint8(auctionItem.DeleteReason);
 
     for (WorldPackets::Item::ItemEnchantData const& enchant : auctionItem.Enchantments)
         data << enchant;
 
+    if (auctionItem.MinBid)
+        data << uint64(*auctionItem.MinBid);
+
+    if (auctionItem.MinIncrement)
+        data << uint64(*auctionItem.MinIncrement);
+
+    if (auctionItem.BuyoutPrice)
+        data << uint64(*auctionItem.BuyoutPrice);
+
+    if (auctionItem.UnitPrice)
+        data << uint64(*auctionItem.UnitPrice);
+
     if (!auctionItem.CensorServerSideInfo)
     {
         data << auctionItem.ItemGuid;
@@ -54,276 +218,438 @@ ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::AuctionHouse::AuctionItem
 
     if (!auctionItem.CensorBidInfo)
     {
-        data << auctionItem.Bidder;
-        data << uint64(auctionItem.BidAmount);
+        if (auctionItem.Bidder)
+            data << *auctionItem.Bidder;
+
+        if (auctionItem.BidAmount)
+            data << uint64(*auctionItem.BidAmount);
     }
 
+    for (WorldPackets::Item::ItemGemData const& gem : auctionItem.Gems)
+        data << gem;
+
+    if (auctionItem.AuctionBucketKey)
+        data << *auctionItem.AuctionBucketKey;
+
     return data;
 }
 
-ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::AuctionHouse::AuctionOwnerNotification const& ownerNotification)
+void AuctionBidderNotification::Initialize(::AuctionEntry const* auction, ::Item const* item)
 {
-    data << int32(ownerNotification.AuctionItemID);
-    data << uint64(ownerNotification.BidAmount);
-    data << ownerNotification.Item;
-    return data;
+    AuctionID = auction->Id;
+    Item.Initialize(item);
+    Bidder = ObjectGuid::Create<HighGuid::Player>(auction->bidder);
 }
 
-ByteBuffer& operator<<(ByteBuffer& data, WorldPackets::AuctionHouse::AuctionBidderNotification const& bidderNotification)
+ByteBuffer& operator<<(ByteBuffer& data, AuctionBidderNotification const& bidderNotification)
 {
-    data << int32(bidderNotification.AuctionItemID);
+    data << int32(bidderNotification.AuctionID);
     data << bidderNotification.Bidder;
     data << bidderNotification.Item;
     return data;
 }
 
-void WorldPackets::AuctionHouse::AuctionOwnerNotification::Initialize(::AuctionEntry const* auction, ::Item const* item)
+void AuctionBrowseQuery::Read()
 {
-    AuctionItemID = auction->Id;
-    Item.Initialize(item);
-    BidAmount = auction->bid;
+    _worldPacket >> Auctioneer;
+    _worldPacket >> Offset;
+    _worldPacket >> MinLevel;
+    _worldPacket >> MaxLevel;
+    _worldPacket >> Filters;
+    KnownPets.resize(_worldPacket.read<uint32>());
+    _worldPacket >> MaxPetLevel;
+    for (uint8& knownPetMask : KnownPets)
+        _worldPacket >> knownPetMask;
+
+    if (_worldPacket.ReadBit())
+        TaintedBy.emplace();
+
+    uint32 nameLength = _worldPacket.ReadBits(8);
+    ItemClassFilters.resize(_worldPacket.ReadBits(3));
+    Sorts.resize(_worldPacket.ReadBits(2));
+
+    for (AuctionSortDef& sortDef : Sorts)
+        _worldPacket >> sortDef;
+
+    if (TaintedBy)
+        _worldPacket >> *TaintedBy;
+
+    Name = _worldPacket.ReadString(nameLength);
+    for (AuctionListFilterClass& filterClass : ItemClassFilters)
+        _worldPacket >> filterClass;
 }
 
-void WorldPackets::AuctionHouse::AuctionBidderNotification::Initialize(::AuctionEntry const* auction, ::Item const* item)
+void AuctionCancelCommoditiesPurchase::Read()
 {
-    AuctionItemID = auction->Id;
-    Item.Initialize(item);
-    Bidder = ObjectGuid::Create<HighGuid::Player>(auction->bidder);
+    _worldPacket >> Auctioneer;
+    if (_worldPacket.ReadBit())
+    {
+        TaintedBy.emplace();
+        _worldPacket >> *TaintedBy;
+    }
 }
 
-void WorldPackets::AuctionHouse::AuctionHelloRequest::Read()
+void AuctionConfirmCommoditiesPurchase::Read()
+{
+    _worldPacket >> Auctioneer;
+    _worldPacket >> ItemID;
+    _worldPacket >> Quantity;
+    if (_worldPacket.ReadBit())
+    {
+        TaintedBy.emplace();
+        _worldPacket >> *TaintedBy;
+    }
+}
+
+void AuctionHelloRequest::Read()
 {
     _worldPacket >> Guid;
 }
 
-WorldPacket const* WorldPackets::AuctionHouse::AuctionHelloResponse::Write()
+void AuctionListBidderItems::Read()
 {
-    _worldPacket << Guid;
-    _worldPacket.WriteBit(OpenForBusiness);
-    _worldPacket.FlushBits();
+    _worldPacket >> Auctioneer;
+    _worldPacket >> Offset;
 
-    return &_worldPacket;
-}
+    if (_worldPacket.ReadBit())
+        TaintedBy.emplace();
 
-WorldPackets::AuctionHouse::AuctionCommandResult::AuctionCommandResult()
-    : ServerPacket(SMSG_AUCTION_COMMAND_RESULT, 4 + 4 + 4 + 8 + 4 + 8 + 8 + 8) { }
+    AuctionIDs.resize(_worldPacket.ReadBits(7));
+    Sorts.resize(_worldPacket.ReadBits(2));
 
-void WorldPackets::AuctionHouse::AuctionCommandResult::InitializeAuction(::AuctionEntry* auction)
-{
-    if (auction)
-    {
-        AuctionItemID   = auction->Id;
-        Money           = auction->bid == auction->buyout ? 0 : auction->bid;
-        MinIncrement    = auction->bid == auction->buyout ? 0 : auction->GetAuctionOutBid();
-        Guid            = ObjectGuid::Create<HighGuid::Player>(auction->bidder);
-    }
+    for (AuctionSortDef& sortDef : Sorts)
+        _worldPacket >> sortDef;
+
+    if (TaintedBy)
+        _worldPacket >> *TaintedBy;
+
+    for (uint32& auctionID : AuctionIDs)
+        _worldPacket >> auctionID;
 }
 
-WorldPacket const* WorldPackets::AuctionHouse::AuctionCommandResult::Write()
+void AuctionListItemsByBucketKey::Read()
 {
-    _worldPacket << uint32(AuctionItemID);
-    _worldPacket << int32(Command);
-    _worldPacket << int32(ErrorCode);
-    _worldPacket << int32(BagResult);
-    _worldPacket << Guid;
-    _worldPacket << uint64(MinIncrement);
-    _worldPacket << uint64(Money);
+    _worldPacket >> Auctioneer;
+    _worldPacket >> Offset;
+    _worldPacket >> Unk;
 
-    return &_worldPacket;
+    if (_worldPacket.ReadBit())
+        TaintedBy.emplace();
+
+    Sorts.resize(_worldPacket.ReadBits(2));
+
+    for (AuctionSortDef& sortDef : Sorts)
+        _worldPacket >> sortDef;
+
+    _worldPacket >> BucketKey;
+
+    if (TaintedBy)
+        _worldPacket >> *TaintedBy;
 }
 
-void WorldPackets::AuctionHouse::AuctionSellItem::Read()
+void AuctionListItemsByItemID::Read()
 {
     _worldPacket >> Auctioneer;
-    _worldPacket >> MinBid;
-    _worldPacket >> BuyoutPrice;
-    _worldPacket >> RunTime;
+    _worldPacket >> ItemID;
+    _worldPacket >> SuffixItemNameDescriptionID;
+    _worldPacket >> Offset;
 
-    Items.resize(_worldPacket.ReadBits(5));
-    _worldPacket.ResetBitPos();
+    if (_worldPacket.ReadBit())
+        TaintedBy.emplace();
 
-    for (WorldPackets::AuctionHouse::AuctionSellItem::AuctionItemForSale& item : Items)
-    {
-        _worldPacket >> item.Guid;
-        _worldPacket >> item.UseCount;
-    }
+    Sorts.resize(_worldPacket.ReadBits(2));
+
+    for (AuctionSortDef& sortDef : Sorts)
+        _worldPacket >> sortDef;
+
+    if (TaintedBy)
+        _worldPacket >> *TaintedBy;
 }
 
-void WorldPackets::AuctionHouse::AuctionPlaceBid::Read()
+void AuctionListItemsByItemKeys::Read()
 {
     _worldPacket >> Auctioneer;
-    _worldPacket >> AuctionItemID;
-    _worldPacket >> BidAmount;
+
+    if (_worldPacket.ReadBit())
+        TaintedBy.emplace();
+
+    BucketKeys.resize(_worldPacket.ReadBits(7));
+    Sorts.resize(_worldPacket.ReadBits(2));
+
+    for (AuctionSortDef& sortDef : Sorts)
+        _worldPacket >> sortDef;
+
+    if (TaintedBy)
+        _worldPacket >> *TaintedBy;
+
+    for (AuctionBucketKey& bucketKey : BucketKeys)
+        _worldPacket >> bucketKey;
 }
 
-void WorldPackets::AuctionHouse::AuctionListBidderItems::Read()
+void AuctionListOwnerItems::Read()
 {
     _worldPacket >> Auctioneer;
     _worldPacket >> Offset;
-    uint8 auctionItemIDsCount = _worldPacket.ReadBits(7);
-    _worldPacket.ResetBitPos();
 
-    for (uint8 i = 0; i < auctionItemIDsCount; i++)
+    if (_worldPacket.ReadBit())
+        TaintedBy.emplace();
+
+    Sorts.resize(_worldPacket.ReadBits(2));
+
+    for (AuctionSortDef& sortDef : Sorts)
+        _worldPacket >> sortDef;
+
+    if (TaintedBy)
+        _worldPacket >> *TaintedBy;
+}
+
+void AuctionPlaceBid::Read()
+{
+    _worldPacket >> Auctioneer;
+    _worldPacket >> AuctionID;
+    _worldPacket >> BidAmount;
+    if (_worldPacket.ReadBit())
     {
-        uint32 AuctionItemID = 0;
-        _worldPacket >> AuctionItemID;
-        AuctionItemIDs.emplace_back(AuctionItemID);
+        TaintedBy.emplace();
+        _worldPacket >> *TaintedBy;
     }
 }
 
-void WorldPackets::AuctionHouse::AuctionRemoveItem::Read()
+void AuctionRemoveItem::Read()
 {
     _worldPacket >> Auctioneer;
-    _worldPacket >> AuctionItemID;
+    _worldPacket >> AuctionID;
+    if (_worldPacket.ReadBit())
+    {
+        TaintedBy.emplace();
+        _worldPacket >> *TaintedBy;
+    }
 }
 
-void WorldPackets::AuctionHouse::AuctionReplicateItems::Read()
+void AuctionReplicateItems::Read()
 {
     _worldPacket >> Auctioneer;
     _worldPacket >> ChangeNumberGlobal;
     _worldPacket >> ChangeNumberCursor;
     _worldPacket >> ChangeNumberTombstone;
     _worldPacket >> Count;
+    if (_worldPacket.ReadBit())
+    {
+        TaintedBy.emplace();
+        _worldPacket >> *TaintedBy;
+    }
 }
 
-WorldPacket const* WorldPackets::AuctionHouse::AuctionListItemsResult::Write()
+void AuctionSellCommodity::Read()
 {
-    _worldPacket << int32(Items.size());
-    _worldPacket << int32(TotalCount);
-    _worldPacket << int32(DesiredDelay);
-    _worldPacket.WriteBit(OnlyUsable);
-    _worldPacket.FlushBits();
+    _worldPacket >> Auctioneer;
+    _worldPacket >> UnitPrice;
+    _worldPacket >> RunTime;
 
-    for (AuctionItem const& item : Items)
-        _worldPacket << item;
+    if (_worldPacket.ReadBit())
+        TaintedBy.emplace();
 
-    return &_worldPacket;
+    Items.resize(_worldPacket.ReadBits(6));
+
+    if (TaintedBy)
+        _worldPacket >> *TaintedBy;
+
+    for (AuctionItemForSale& item : Items)
+        _worldPacket >> item;
 }
 
-WorldPacket const* WorldPackets::AuctionHouse::AuctionListOwnerItemsResult::Write()
+void AuctionSellItem::Read()
 {
-    _worldPacket << int32(Items.size());
-    _worldPacket << uint32(TotalCount);
-    _worldPacket << uint32(DesiredDelay);
+    _worldPacket >> Auctioneer;
+    _worldPacket >> MinBid;
+    _worldPacket >> BuyoutPrice;
+    _worldPacket >> RunTime;
 
-    for (AuctionItem const& item : Items)
-        _worldPacket << item;
+    if (_worldPacket.ReadBit())
+        TaintedBy.emplace();
+
+    Items.resize(_worldPacket.ReadBits(6));
+
+    if (TaintedBy)
+        _worldPacket >> *TaintedBy;
+
+    for (AuctionItemForSale& item : Items)
+        _worldPacket >> item;
+}
+
+void AuctionSetFavoriteItem::Read()
+{
+    IsNotFavorite = _worldPacket.ReadBit();
+    _worldPacket >> Item;
+}
+
+void AuctionStartCommoditiesPurchase::Read()
+{
+    _worldPacket >> Auctioneer;
+    _worldPacket >> ItemID;
+    _worldPacket >> Quantity;
+    if (_worldPacket.ReadBit())
+    {
+        TaintedBy.emplace();
+        _worldPacket >> *TaintedBy;
+    }
+}
+
+WorldPacket const* AuctionClosedNotification::Write()
+{
+    _worldPacket << Info;
+    _worldPacket << float(ProceedsMailDelay);
+    _worldPacket.WriteBit(Sold);
+    _worldPacket.FlushBits();
 
     return &_worldPacket;
 }
 
-WorldPacket const* WorldPackets::AuctionHouse::AuctionListBidderItemsResult::Write()
+void AuctionCommandResult::InitializeAuction(::AuctionEntry const* auction)
 {
-    _worldPacket << int32(Items.size());
-    _worldPacket << uint32(TotalCount);
-    _worldPacket << uint32(DesiredDelay);
+    if (auction)
+    {
+        AuctionID = auction->Id;
+        Money = auction->bid == auction->buyout ? 0 : auction->bid;
+        MinIncrement = auction->bid == auction->buyout ? 0 : auction->GetAuctionOutBid();
+        Guid = ObjectGuid::Create<HighGuid::Player>(auction->bidder);
+    }
+}
 
-    for (AuctionItem const& item : Items)
-        _worldPacket << item;
+WorldPacket const* AuctionCommandResult::Write()
+{
+    _worldPacket << int32(AuctionID);
+    _worldPacket << int32(Command);
+    _worldPacket << int32(ErrorCode);
+    _worldPacket << int32(BagResult);
+    _worldPacket << Guid;
+    _worldPacket << uint64(MinIncrement);
+    _worldPacket << uint64(Money);
 
     return &_worldPacket;
 }
 
-void WorldPackets::AuctionHouse::AuctionListItems::Read()
+WorldPacket const* AuctionCommodityPriceUpdate::Write()
 {
-    _worldPacket >> Offset;
-    _worldPacket >> Auctioneer;
-    _worldPacket >> MinLevel;
-    _worldPacket >> MaxLevel;
-    _worldPacket >> Quality;
-    _worldPacket >> SortCount;
-    KnownPets.resize(_worldPacket.read<uint32>());
-    _worldPacket >> MaxPetLevel;
-    for (std::size_t i = 0; i < KnownPets.size(); ++i)
-        _worldPacket >> KnownPets[i];
+    _worldPacket.WriteBit(TotalPrice.is_initialized());
+    _worldPacket.WriteBit(Quantity.is_initialized());
+    _worldPacket.WriteBit(QuoteDuration.is_initialized());
+    _worldPacket << int32(Unknown830);
+    _worldPacket << uint32(DesiredDelay);
 
-    Name = _worldPacket.ReadString(_worldPacket.ReadBits(8));
-    ClassFilters.resize(_worldPacket.ReadBits(3));
-    OnlyUsable = _worldPacket.ReadBit();
-    ExactMatch = _worldPacket.ReadBit();
+    if (TotalPrice)
+        _worldPacket << uint64(*TotalPrice);
 
-    for (ClassFilter& classFilter : ClassFilters)
-    {
-        _worldPacket >> classFilter.ItemClass;
-        classFilter.SubClassFilters.resize(_worldPacket.ReadBits(5));
-        for (ClassFilter::SubClassFilter& subclassFilter : classFilter.SubClassFilters)
-        {
-            _worldPacket >> subclassFilter.ItemSubclass;
-            _worldPacket >> subclassFilter.InvTypeMask;
-        }
-    }
+    if (Quantity)
+        _worldPacket << uint32(*Quantity);
 
-    _worldPacket.read_skip<uint32>(); // DataSize = (SortCount * 2)
-    for (int32 i = 0; i < SortCount; i++)
-    {
-        WorldPackets::AuctionHouse::AuctionListItems::Sort sort;
-        _worldPacket >> sort.Type;
-        _worldPacket >> sort.Direction;
-        DataSort.push_back(sort);
-    }
+    if (QuoteDuration)
+        _worldPacket << int32(*QuoteDuration);
+
+    return &_worldPacket;
 }
 
-void WorldPackets::AuctionHouse::AuctionListOwnerItems::Read()
+WorldPacket const* AuctionHelloResponse::Write()
 {
-    _worldPacket >> Auctioneer;
-    _worldPacket >> Offset;
+    _worldPacket << Guid;
+    _worldPacket.WriteBit(OpenForBusiness);
+    _worldPacket.FlushBits();
+
+    return &_worldPacket;
 }
 
-WorldPackets::AuctionHouse::AuctionListPendingSalesResult::AuctionListPendingSalesResult() : ServerPacket(SMSG_AUCTION_LIST_PENDING_SALES_RESULT, 140)
+WorldPacket const* AuctionListBidderItemsResult::Write()
 {
+    _worldPacket << int32(Items.size());
+    _worldPacket << uint32(DesiredDelay);
+    _worldPacket.WriteBit(HasMoreResults);
+    _worldPacket.FlushBits();
+
+    for (AuctionItem const& item : Items)
+        _worldPacket << item;
+
+    return &_worldPacket;
 }
 
-WorldPackets::AuctionHouse::AuctionListPendingSalesResult::~AuctionListPendingSalesResult()
+WorldPacket const* AuctionListBucketItemsResult::Write()
 {
+    _worldPacket << uint32(Buckets.size());
+    _worldPacket << uint32(DesiredDelay);
+    _worldPacket << int32(Unknown830_0);
+    _worldPacket << int32(Unknown830_1);
+    _worldPacket.WriteBits(BrowseMode, 1);
+    _worldPacket.WriteBit(HasMoreResults);
+    _worldPacket.FlushBits();
+
+    for (BucketInfo const& bucketInfo : Buckets)
+        _worldPacket << bucketInfo;
+
+    return &_worldPacket;
 }
 
-WorldPacket const* WorldPackets::AuctionHouse::AuctionListPendingSalesResult::Write()
+WorldPacket const* AuctionListFavoriteItemsResult::Write()
 {
-    _worldPacket << uint32(Mails.size());
-    _worldPacket << int32(TotalNumRecords);
+    _worldPacket << uint32(DesiredDelay);
+    _worldPacket.WriteBits(Items.size(), 7);
+    _worldPacket.FlushBits();
 
-    for (auto const& mail : Mails)
-        _worldPacket << mail;
+    for (AuctionFavoriteInfo const& favoriteInfo : Items)
+        _worldPacket << favoriteInfo;
 
     return &_worldPacket;
 }
 
-WorldPacket const* WorldPackets::AuctionHouse::AuctionClosedNotification::Write()
+WorldPacket const* AuctionListItemsResult::Write()
 {
-    _worldPacket << Info;
-    _worldPacket << float(ProceedsMailDelay);
-    _worldPacket.WriteBit(Sold);
+    _worldPacket << uint32(Items.size());
+    _worldPacket << uint32(Unknown830);
+    _worldPacket << uint32(TotalCount);
+    _worldPacket << uint32(DesiredDelay);
+    _worldPacket.WriteBits(ListType, 2);
+    _worldPacket.WriteBit(HasMoreResults);
     _worldPacket.FlushBits();
 
+    _worldPacket << BucketKey;
+
+    for (AuctionItem const& item : Items)
+        _worldPacket << item;
+
     return &_worldPacket;
 }
 
-WorldPacket const* WorldPackets::AuctionHouse::AuctionOwnerBidNotification::Write()
+WorldPacket const* AuctionListOwnerItemsResult::Write()
 {
-    _worldPacket << Info;
-    _worldPacket << uint64(MinIncrement);
-    _worldPacket << Bidder;
+    _worldPacket << int32(Items.size());
+    _worldPacket << int32(SoldItems.size());
+    _worldPacket << uint32(DesiredDelay);
+    _worldPacket.WriteBit(HasMoreResults);
+    _worldPacket.FlushBits();
+
+    for (AuctionItem const& item : Items)
+        _worldPacket << item;
 
     return &_worldPacket;
 }
 
-WorldPacket const* WorldPackets::AuctionHouse::AuctionWonNotification::Write()
+WorldPacket const* AuctionOutbidNotification::Write()
 {
     _worldPacket << Info;
+    _worldPacket << uint64(BidAmount);
+    _worldPacket << uint64(MinIncrement);
 
     return &_worldPacket;
 }
 
-WorldPacket const* WorldPackets::AuctionHouse::AuctionOutBidNotification::Write()
+WorldPacket const* AuctionOwnerBidNotification::Write()
 {
     _worldPacket << Info;
-    _worldPacket << uint64(BidAmount);
     _worldPacket << uint64(MinIncrement);
+    _worldPacket << Bidder;
 
     return &_worldPacket;
 }
 
-WorldPacket const* WorldPackets::AuctionHouse::AuctionReplicateResponse::Write()
+WorldPacket const* AuctionReplicateResponse::Write()
 {
     _worldPacket << uint32(Result);
     _worldPacket << uint32(DesiredDelay);
@@ -332,8 +658,17 @@ WorldPacket const* WorldPackets::AuctionHouse::AuctionReplicateResponse::Write()
     _worldPacket << uint32(ChangeNumberTombstone);
     _worldPacket << uint32(Items.size());
 
-    for (auto const& item : Items)
+    for (AuctionItem const& item : Items)
         _worldPacket << item;
 
     return &_worldPacket;
 }
+
+WorldPacket const* AuctionWonNotification::Write()
+{
+    _worldPacket << Info;
+
+    return &_worldPacket;
+}
+}
+}
diff --git a/src/server/game/Server/Packets/AuctionHousePackets.h b/src/server/game/Server/Packets/AuctionHousePackets.h
index bd8f169be81..cda691e5cfc 100644
--- a/src/server/game/Server/Packets/AuctionHousePackets.h
+++ b/src/server/game/Server/Packets/AuctionHousePackets.h
@@ -19,33 +19,94 @@
 #define AuctionHousePackets_h__
 
 #include "Packet.h"
+#include "AddonPackets.h"
 #include "DBCEnums.h"
 #include "ItemPacketsCommon.h"
 #include "ObjectGuid.h"
 
 struct AuctionEntry;
+enum class AuctionHouseSortOrder : uint8;
 
 namespace WorldPackets
 {
-    namespace Mail
-    {
-        struct MailListEntry;
-    }
-
     namespace AuctionHouse
     {
-        struct AuctionItem
+        struct AuctionBucketKey
+        {
+            uint32 ItemID = 0;
+            uint16 ItemLevel = 0;
+            Optional<uint16> BattlePetSpeciesID;
+            Optional<uint16> SuffixItemNameDescriptionID;
+        };
+
+        struct AuctionListFilterSubClass
+        {
+            int32 ItemSubclass = 0;
+            uint32 InvTypeMask = 0;
+        };
+
+        struct AuctionListFilterClass
+        {
+            int32 ItemClass = 0;
+            Array<AuctionListFilterSubClass, 31> SubClassFilters;
+        };
+
+        struct AuctionSortDef
+        {
+            AuctionHouseSortOrder SortOrder = AuctionHouseSortOrder(0);
+            bool ReverseSort = false;
+        };
+
+        struct AuctionItemForSale
+        {
+            ObjectGuid Guid;
+            uint32 UseCount = 0;
+        };
+
+        struct AuctionFavoriteInfo
         {
+            uint32 Order = 0;
+            uint32 ItemID = 0;
+            uint32 ItemLevel = 0;
+            uint32 BattlePetSpeciesID = 0;
+            uint32 ItemSuffix = 0;
+        };
+
+        struct AuctionOwnerNotification
+        {
+            void Initialize(::AuctionEntry const* auction, ::Item const* item);
+
+            int32 AuctionID = 0;
+            uint64 BidAmount = 0;
             Item::ItemInstance Item;
+        };
+
+        struct BucketInfo
+        {
+            AuctionBucketKey Key;
+            int32 TotalQuantity = 0;
+            uint64 MinPrice = 0;
+            std::vector<int32> ItemModifiedAppearanceIDs;
+            Optional<uint8> MaxBattlePetQuality;
+            Optional<uint8> MaxBattlePetLevel;
+            Optional<uint8> BattlePetBreedID;
+            bool ContainsOwnerItem = false;
+            bool ContainsOnlyCollectedAppearances = false;
+        };
+
+        struct AuctionItem
+        {
+            Optional<Item::ItemInstance> Item;
             int32 Count = 0;
             int32 Charges = 0;
             std::vector<Item::ItemEnchantData> Enchantments;
             int32 Flags = 0;
-            int32 AuctionItemID = 0;
+            int32 AuctionID = 0;
             ObjectGuid Owner;
-            uint64 MinBid = 0;
-            uint64 MinIncrement = 0;
-            uint64 BuyoutPrice = 0;
+            Optional<uint64> MinBid;
+            Optional<uint64> MinIncrement;
+            Optional<uint64> BuyoutPrice;
+            Optional<uint64> UnitPrice;
             int32 DurationLeft = 0;
             uint8 DeleteReason = 0;
             bool CensorServerSideInfo = false;
@@ -53,27 +114,63 @@ namespace WorldPackets
             ObjectGuid ItemGuid;
             ObjectGuid OwnerAccountID;
             uint32 EndTime = 0;
-            ObjectGuid Bidder;
-            uint64 BidAmount = 0;
+            Optional<ObjectGuid> Bidder;
+            Optional<uint64> BidAmount;
             std::vector<Item::ItemGemData> Gems;
+            Optional<AuctionBucketKey> AuctionBucketKey;
         };
 
-        struct AuctionOwnerNotification
+        struct AuctionBidderNotification
         {
             void Initialize(::AuctionEntry const* auction, ::Item const* item);
 
-            int32 AuctionItemID = 0;
-            uint64 BidAmount = 0;
+            int32 AuctionID = 0;
+            ObjectGuid Bidder;
             Item::ItemInstance Item;
         };
 
-        struct AuctionBidderNotification
+        class AuctionBrowseQuery final : public ClientPacket
         {
-            void Initialize(::AuctionEntry const* auction, ::Item const* item);
+        public:
+            AuctionBrowseQuery(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_BROWSE_QUERY, std::move(packet)) { }
 
-            int32 AuctionItemID = 0;
-            ObjectGuid Bidder;
-            Item::ItemInstance Item;
+            void Read() override;
+
+            ObjectGuid Auctioneer;
+            uint32 Offset = 0;
+            uint8 MinLevel = 1;
+            uint8 MaxLevel = MAX_LEVEL;
+            uint32 Filters = 0;
+            Array<uint8, BATTLE_PET_SPECIES_MAX_ID / 8 + 1> KnownPets;
+            int8 MaxPetLevel = 0;
+            Optional<Addon::AddOnInfo> TaintedBy;
+            std::string Name;
+            Array<AuctionListFilterClass, 7> ItemClassFilters;
+            Array<AuctionSortDef, 2> Sorts;
+        };
+
+        class AuctionCancelCommoditiesPurchase final : public ClientPacket
+        {
+        public:
+            AuctionCancelCommoditiesPurchase(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_CANCEL_COMMODITIES_PURCHASE, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Auctioneer;
+            Optional<Addon::AddOnInfo> TaintedBy;
+        };
+
+        class AuctionConfirmCommoditiesPurchase final : public ClientPacket
+        {
+        public:
+            AuctionConfirmCommoditiesPurchase(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_CONFIRM_COMMODITIES_PURCHASE, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Auctioneer;
+            int32 ItemID = 0;
+            uint32 Quantity = 0;
+            Optional<Addon::AddOnInfo> TaintedBy;
         };
 
         class AuctionHelloRequest final : public ClientPacket
@@ -82,87 +179,92 @@ namespace WorldPackets
             AuctionHelloRequest(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_HELLO_REQUEST, std::move(packet)) { }
 
             void Read() override;
+
             ObjectGuid Guid;
         };
 
-        class AuctionHelloResponse final : public ServerPacket
+        class AuctionListBidderItems final : public ClientPacket
         {
         public:
-            AuctionHelloResponse() : ServerPacket(SMSG_AUCTION_HELLO_RESPONSE, 1 + 16) { }
+            AuctionListBidderItems(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_LIST_BIDDER_ITEMS, std::move(packet)) { }
 
-            WorldPacket const* Write() override;
+            void Read() override;
 
-            ObjectGuid Guid;
-            bool OpenForBusiness = true;
+            ObjectGuid Auctioneer;
+            uint32 Offset = 0;
+            Array<uint32, 100> AuctionIDs;
+            Array<AuctionSortDef, 2> Sorts;
+            Optional<Addon::AddOnInfo> TaintedBy;
         };
 
-        class AuctionCommandResult final : public ServerPacket
+        class AuctionListItemsByBucketKey final : public ClientPacket
         {
-            public:
-                AuctionCommandResult();
-
-                /**
-                 * @fn  void WorldPackets::AuctionHousePackets::AuctionCommandResult::InitializeAuction(AuctionEntry* auction);
-                 *
-                 * @brief   Initialize the following fields: AuctionId, Bid, AuctionOutBid, Bidder
-                 *
-                 * @param   auction         The relevant auction object
-                 */
-                void InitializeAuction(::AuctionEntry* auction);
+        public:
+            AuctionListItemsByBucketKey(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_LIST_ITEMS_BY_BUCKET_KEY, std::move(packet)) { }
 
-                WorldPacket const* Write() override;
+            void Read() override;
 
-                uint32 AuctionItemID = 0; ///< the id of the auction that triggered this notification
-                uint32 Command       = 0; ///< the type of action that triggered this notification. Possible values are @ref AuctionAction
-                int32 ErrorCode      = 0; ///< the error code that was generated when trying to perform the action. Possible values are @ref AuctionError
-                uint64 Money         = 0; ///< the amount of money that the player bid in copper
-                int32 BagResult      = 0; ///< the bid error. Possible values are @ref AuctionError
-                ObjectGuid Guid;          ///< the GUID of the bidder for this auction.
-                uint64 MinIncrement  = 0; ///< the sum of outbid is (1% of current bid) * 5, if the bid is too small, then this value is 1 copper.
+            ObjectGuid Auctioneer;
+            uint32 Offset = 0;
+            int8 Unk = 0;
+            Optional<Addon::AddOnInfo> TaintedBy;
+            Array<AuctionSortDef, 2> Sorts;
+            AuctionBucketKey BucketKey;
         };
 
-        class AuctionSellItem final : public ClientPacket
+        class AuctionListItemsByItemID final : public ClientPacket
         {
         public:
-            struct AuctionItemForSale
-            {
-                ObjectGuid Guid;
-                uint32 UseCount = 0;
-            };
-
-            AuctionSellItem(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_SELL_ITEM, std::move(packet)) { }
+            AuctionListItemsByItemID(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_LIST_ITEMS_BY_ITEM_ID, std::move(packet)) { }
 
             void Read() override;
 
-            uint64 BuyoutPrice = 0;
             ObjectGuid Auctioneer;
-            uint64 MinBid = 0;
-            uint32 RunTime = 0;
-            Array<AuctionItemForSale, 32> Items;
+            int32 ItemID = 0;
+            int32 SuffixItemNameDescriptionID = 0;
+            uint32 Offset = 0;
+            Optional<Addon::AddOnInfo> TaintedBy;
+            Array<AuctionSortDef, 2> Sorts;
         };
 
-        class AuctionPlaceBid final : public ClientPacket
+        class AuctionListItemsByItemKeys final : public ClientPacket
         {
         public:
-            AuctionPlaceBid(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_PLACE_BID, std::move(packet)) { }
+            AuctionListItemsByItemKeys(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_LIST_ITEMS_BY_ITEM_KEYS, std::move(packet)) { }
 
             void Read() override;
 
             ObjectGuid Auctioneer;
-            uint64 BidAmount = 0;
-            int32 AuctionItemID = 0;
+            uint32 Offset = 0;
+            Optional<Addon::AddOnInfo> TaintedBy;
+            Array<AuctionBucketKey, 100> BucketKeys;
+            Array<AuctionSortDef, 2> Sorts;
         };
 
-        class AuctionListBidderItems final : public ClientPacket
+        class AuctionListOwnerItems final : public ClientPacket
         {
         public:
-            AuctionListBidderItems(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_LIST_BIDDER_ITEMS, std::move(packet)) { }
+            AuctionListOwnerItems(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_LIST_OWNER_ITEMS, std::move(packet)) { }
 
             void Read() override;
 
+            ObjectGuid Auctioneer;
             uint32 Offset = 0;
-            std::vector<uint32> AuctionItemIDs;
+            Optional<Addon::AddOnInfo> TaintedBy;
+            Array<AuctionSortDef, 2> Sorts;
+        };
+
+        class AuctionPlaceBid final : public ClientPacket
+        {
+        public:
+            AuctionPlaceBid(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_PLACE_BID, std::move(packet)) { }
+
+            void Read() override;
+
             ObjectGuid Auctioneer;
+            uint64 BidAmount = 0;
+            int32 AuctionID = 0;
+            Optional<Addon::AddOnInfo> TaintedBy;
         };
 
         class AuctionRemoveItem final : public ClientPacket
@@ -173,7 +275,8 @@ namespace WorldPackets
             void Read() override;
 
             ObjectGuid Auctioneer;
-            int32 AuctionItemID = 0;
+            int32 AuctionID = 0;
+            Optional<Addon::AddOnInfo> TaintedBy;
         };
 
         class AuctionReplicateItems final : public ClientPacket
@@ -188,154 +291,195 @@ namespace WorldPackets
             uint32 ChangeNumberCursor = 0;
             uint32 ChangeNumberTombstone = 0;
             uint32 Count = 0;
+            Optional<Addon::AddOnInfo> TaintedBy;
+        };
+
+        class AuctionSellCommodity final : public ClientPacket
+        {
+        public:
+            AuctionSellCommodity(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_SELL_COMMODITY, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Auctioneer;
+            uint64 UnitPrice = 0;
+            uint32 RunTime = 0;
+            Optional<Addon::AddOnInfo> TaintedBy;
+            Array<AuctionItemForSale, 64> Items;
         };
 
-        class AuctionListPendingSales final : public ClientPacket
+        class AuctionSellItem final : public ClientPacket
         {
         public:
-            AuctionListPendingSales(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_LIST_PENDING_SALES, std::move(packet)) { }
+            AuctionSellItem(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_SELL_ITEM, std::move(packet)) { }
 
-            void Read() override { }
+            void Read() override;
+
+            uint64 BuyoutPrice = 0;
+            ObjectGuid Auctioneer;
+            uint64 MinBid = 0;
+            uint32 RunTime = 0;
+            Optional<Addon::AddOnInfo> TaintedBy;
+            Array<AuctionItemForSale, 64> Items;
         };
 
-        class AuctionListItemsResult final : public ServerPacket
+        class AuctionSetFavoriteItem final : public ClientPacket
         {
         public:
-            AuctionListItemsResult() : ServerPacket(SMSG_AUCTION_LIST_ITEMS_RESULT, 150) { }
+            AuctionSetFavoriteItem(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_SET_FAVORITE_ITEM, std::move(packet)) { }
+
+            void Read() override;
+
+            AuctionFavoriteInfo Item;
+            bool IsNotFavorite = true;
+        };
+
+        class AuctionStartCommoditiesPurchase final : public ClientPacket
+        {
+        public:
+            AuctionStartCommoditiesPurchase(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_START_COMMODITIES_PURCHASE, std::move(packet)) { }
+
+            void Read() override;
+
+            ObjectGuid Auctioneer;
+            int32 ItemID = 0;
+            uint32 Quantity = 0;
+            Optional<Addon::AddOnInfo> TaintedBy;
+        };
+
+        class AuctionClosedNotification final : public ServerPacket
+        {
+        public:
+            AuctionClosedNotification() : ServerPacket(SMSG_AUCTION_CLOSED_NOTIFICATION, 45) { }
 
             WorldPacket const* Write() override;
 
-            uint32 DesiredDelay = 0;
-            std::vector<AuctionItem> Items;
-            bool OnlyUsable = true;
-            uint32 TotalCount = 0;
+            AuctionOwnerNotification Info;
+            float ProceedsMailDelay = 0.0f;
+            bool Sold = true;
         };
 
-        class AuctionListOwnerItemsResult final : public ServerPacket
+        class AuctionCommandResult final : public ServerPacket
         {
         public:
-            AuctionListOwnerItemsResult() : ServerPacket(SMSG_AUCTION_LIST_OWNER_ITEMS_RESULT, 149) { }
+            AuctionCommandResult() : ServerPacket(SMSG_AUCTION_COMMAND_RESULT, 4 + 4 + 4 + 8 + 4 + 8 + 8 + 8) { }
+
+            /**
+             * @fn  void WorldPackets::AuctionHousePackets::AuctionCommandResult::InitializeAuction(AuctionEntry* auction);
+             *
+             * @brief   Initialize the following fields: AuctionId, Bid, AuctionOutBid, Bidder
+             *
+             * @param   auction         The relevant auction object
+             */
+            void InitializeAuction(::AuctionEntry const* auction);
 
             WorldPacket const* Write() override;
 
-            uint32 DesiredDelay = 0;
-            uint32 TotalCount = 0;
-            std::vector<AuctionItem> Items;
+            int32 AuctionID      = 0; ///< the id of the auction that triggered this notification
+            int32 Command        = 0; ///< the type of action that triggered this notification. Possible values are @ref AuctionAction
+            int32 ErrorCode      = 0; ///< the error code that was generated when trying to perform the action. Possible values are @ref AuctionError
+            int32 BagResult      = 0; ///< the bid error. Possible values are @ref AuctionError
+            ObjectGuid Guid;          ///< the GUID of the bidder for this auction.
+            uint64 MinIncrement  = 0; ///< the sum of outbid is (1% of current bid) * 5, if the bid is too small, then this value is 1 copper.
+            uint64 Money         = 0; ///< the amount of money that the player bid in copper
         };
 
-        class AuctionListBidderItemsResult final : public ServerPacket
+        class AuctionCommodityPriceUpdate final : public ServerPacket
         {
         public:
-            AuctionListBidderItemsResult() : ServerPacket(SMSG_AUCTION_LIST_BIDDER_ITEMS_RESULT, 149) { }
+            AuctionCommodityPriceUpdate() : ServerPacket(SMSG_AUCTION_COMMODITY_PRICE_UPDATE, 1 + 8 + 4 + 4 + 4 + 4) { }
 
             WorldPacket const* Write() override;
 
+            Optional<uint64> TotalPrice;
+            Optional<uint32> Quantity;
+            Optional<int32> QuoteDuration;
+            int32 Unknown830 = 0;
             uint32 DesiredDelay = 0;
-            uint32 TotalCount = 0;
-            std::vector<AuctionItem> Items;
         };
 
-        class AuctionListOwnerItems final : public ClientPacket
+        class AuctionHelloResponse final : public ServerPacket
         {
         public:
-            AuctionListOwnerItems(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_LIST_OWNER_ITEMS, std::move(packet)) { }
+            AuctionHelloResponse() : ServerPacket(SMSG_AUCTION_HELLO_RESPONSE, 1 + 16) { }
 
-            void Read() override;
+            WorldPacket const* Write() override;
 
-            ObjectGuid Auctioneer;
-            uint32 Offset = 0;
+            ObjectGuid Guid;
+            bool OpenForBusiness = true;
         };
 
-        class AuctionListItems final : public ClientPacket
+        class AuctionListBidderItemsResult final : public ServerPacket
         {
         public:
-            struct Sort
-            {
-                uint8 Type = 0;
-                uint8 Direction = 0;
-            };
-
-            struct ClassFilter
-            {
-                struct SubClassFilter
-                {
-                    int32 ItemSubclass;
-                    uint32 InvTypeMask;
-                };
-
-                int32 ItemClass;
-                Array<SubClassFilter, 31> SubClassFilters;
-            };
-
-            AuctionListItems(WorldPacket&& packet) : ClientPacket(CMSG_AUCTION_LIST_ITEMS, std::move(packet)) { }
+            AuctionListBidderItemsResult() : ServerPacket(SMSG_AUCTION_LIST_BIDDER_ITEMS_RESULT, 149) { }
 
-            void Read() override;
+            WorldPacket const* Write() override;
 
-            uint32 Offset = 0;
-            ObjectGuid Auctioneer;
-            uint8 MinLevel = 1;
-            uint8 MaxLevel = 100;
-            int32 Quality = 0;
-            uint8 SortCount = 0;
-            Array<uint8, BATTLE_PET_SPECIES_MAX_ID / 8 + 1> KnownPets;
-            int8 MaxPetLevel = 0;
-            std::string Name;
-            Array<ClassFilter, 7> ClassFilters;
-            bool ExactMatch = true;
-            bool OnlyUsable = false;
-            std::vector<Sort> DataSort;
+            std::vector<AuctionItem> Items;
+            uint32 DesiredDelay = 0;
+            bool HasMoreResults = false;
         };
 
-        class AuctionListPendingSalesResult final : public ServerPacket
+        class AuctionListBucketItemsResult final : public ServerPacket
         {
         public:
-            AuctionListPendingSalesResult();
-            ~AuctionListPendingSalesResult();
+            AuctionListBucketItemsResult() : ServerPacket(SMSG_AUCTION_LIST_BUCKET_ITEMS_RESULT) { }
 
             WorldPacket const* Write() override;
 
-            std::vector<Mail::MailListEntry> Mails;
-            int32 TotalNumRecords = 0;
+            std::vector<BucketInfo> Buckets;
+            uint32 DesiredDelay = 0;
+            int32 Unknown830_0 = 0;
+            int32 Unknown830_1 = 0;
+            int32 BrowseMode = 0;
+            bool HasMoreResults = false;
         };
 
-        class AuctionClosedNotification final : public ServerPacket
+        class AuctionListFavoriteItemsResult final : public ServerPacket
         {
         public:
-            AuctionClosedNotification() : ServerPacket(SMSG_AUCTION_CLOSED_NOTIFICATION, 45) { }
+            AuctionListFavoriteItemsResult() : ServerPacket(SMSG_AUCTION_LIST_FAVORITE_ITEMS_RESULT, 4 + 4 + 20 * 100) { }
 
             WorldPacket const* Write() override;
 
-            AuctionOwnerNotification Info;
-            float ProceedsMailDelay = 0.0f;
-            bool Sold = true;
+            uint32 DesiredDelay = 0;
+            std::vector<AuctionFavoriteInfo> Items;
         };
 
-        class AuctionOwnerBidNotification final : public ServerPacket
+        class AuctionListItemsResult final : public ServerPacket
         {
         public:
-            AuctionOwnerBidNotification() : ServerPacket(SMSG_AUCTION_OWNER_BID_NOTIFICATION, 62) { }
+            AuctionListItemsResult() : ServerPacket(SMSG_AUCTION_LIST_ITEMS_RESULT, 150) { }
 
             WorldPacket const* Write() override;
 
-            AuctionOwnerNotification Info;
-            ObjectGuid Bidder;
-            uint64 MinIncrement = 0;
+            std::vector<AuctionItem> Items;
+            uint32 Unknown830 = 0;
+            uint32 TotalCount = 0;
+            uint32 DesiredDelay = 0;
+            uint32 ListType = 0;
+            bool HasMoreResults = false;
+            AuctionBucketKey BucketKey;
         };
 
-        class AuctionWonNotification final : public ServerPacket
+        class AuctionListOwnerItemsResult final : public ServerPacket
         {
         public:
-            AuctionWonNotification() : ServerPacket(SMSG_AUCTION_WON_NOTIFICATION, 46) { }
+            AuctionListOwnerItemsResult() : ServerPacket(SMSG_AUCTION_LIST_OWNER_ITEMS_RESULT, 149) { }
 
             WorldPacket const* Write() override;
 
-            AuctionBidderNotification Info;
+            std::vector<AuctionItem> Items;
+            std::vector<AuctionItem> SoldItems;
+            uint32 DesiredDelay = 0;
+            bool HasMoreResults = false;
         };
 
-        class AuctionOutBidNotification final : public ServerPacket
+        class AuctionOutbidNotification final : public ServerPacket
         {
         public:
-            AuctionOutBidNotification() : ServerPacket(SMSG_AUCTION_OUTBID_NOTIFICATION, 62) { }
+            AuctionOutbidNotification() : ServerPacket(SMSG_AUCTION_OUTBID_NOTIFICATION, 62) { }
 
             WorldPacket const* Write() override;
 
@@ -344,6 +488,18 @@ namespace WorldPackets
             uint64 MinIncrement = 0;
         };
 
+        class AuctionOwnerBidNotification final : public ServerPacket
+        {
+        public:
+            AuctionOwnerBidNotification() : ServerPacket(SMSG_AUCTION_OWNER_BID_NOTIFICATION, 62) { }
+
+            WorldPacket const* Write() override;
+
+            AuctionOwnerNotification Info;
+            ObjectGuid Bidder;
+            uint64 MinIncrement = 0;
+        };
+
         class AuctionReplicateResponse final : public ServerPacket
         {
         public:
@@ -358,6 +514,16 @@ namespace WorldPackets
             uint32 Result = 0;
             std::vector<AuctionItem> Items;
         };
+
+        class AuctionWonNotification final : public ServerPacket
+        {
+        public:
+            AuctionWonNotification() : ServerPacket(SMSG_AUCTION_WON_NOTIFICATION, 46) { }
+
+            WorldPacket const* Write() override;
+
+            AuctionBidderNotification Info;
+        };
     }
 }
 
diff --git a/src/server/game/Server/Protocol/Opcodes.cpp b/src/server/game/Server/Protocol/Opcodes.cpp
index 3fe7fd1d7da..3e9ae794b3a 100644
--- a/src/server/game/Server/Protocol/Opcodes.cpp
+++ b/src/server/game/Server/Protocol/Opcodes.cpp
@@ -164,9 +164,9 @@ void OpcodeTable::Initialize()
     DEFINE_HANDLER(CMSG_ATTACK_STOP,                                        STATUS_LOGGEDIN,  PROCESS_INPLACE,      &WorldSession::HandleAttackStopOpcode);
     DEFINE_HANDLER(CMSG_ATTACK_SWING,                                       STATUS_LOGGEDIN,  PROCESS_INPLACE,      &WorldSession::HandleAttackSwingOpcode);
     DEFINE_HANDLER(CMSG_AUCTION_BROWSE_QUERY,                               STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
-    DEFINE_HANDLER(CMSG_AUCTION_HELLO_REQUEST,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleAuctionHelloOpcode);
     DEFINE_HANDLER(CMSG_AUCTION_CANCEL_COMMODITIES_PURCHASE,                STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_AUCTION_CONFIRM_COMMODITIES_PURCHASE,               STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
+    DEFINE_HANDLER(CMSG_AUCTION_HELLO_REQUEST,                              STATUS_LOGGEDIN,  PROCESS_THREADUNSAFE, &WorldSession::HandleAuctionHelloOpcode);
     DEFINE_HANDLER(CMSG_AUCTION_LIST_BIDDER_ITEMS,                          STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_AUCTION_LIST_ITEMS_BY_BUCKET_KEY,                   STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
     DEFINE_HANDLER(CMSG_AUCTION_LIST_ITEMS_BY_ITEM_ID,                      STATUS_UNHANDLED, PROCESS_THREADUNSAFE, &WorldSession::Handle_NULL);
diff --git a/src/server/game/Server/Protocol/Opcodes.h b/src/server/game/Server/Protocol/Opcodes.h
index b114c55c8ba..7c3722d9a1c 100644
--- a/src/server/game/Server/Protocol/Opcodes.h
+++ b/src/server/game/Server/Protocol/Opcodes.h
@@ -788,8 +788,6 @@ enum OpcodeClient : uint16
     CMSG_WORLD_PORT_RESPONSE                          = 0x35F9,
     CMSG_WRAP_ITEM                                    = 0x3994,
 
-    CMSG_AUCTION_LIST_ITEMS                           = 0xBADD,
-    CMSG_AUCTION_LIST_PENDING_SALES                   = 0xBADD,
     CMSG_BF_MGR_ENTRY_INVITE_RESPONSE                 = 0xBADD,
     CMSG_BF_MGR_QUEUE_INVITE_RESPONSE                 = 0xBADD,
     CMSG_BF_MGR_QUEUE_EXIT_REQUEST                    = 0xBADD,
@@ -1836,7 +1834,6 @@ enum OpcodeServer : uint16
 
     // Deleted opcodes, here only to allow compile
     SMSG_ARENA_TEAM_STATS                             = 0xBADD,
-    SMSG_AUCTION_LIST_PENDING_SALES_RESULT            = 0xBADD,
     SMSG_BUY_BANK_SLOT_RESULT                         = 0xBADD,
     SMSG_BF_MGR_EJECTED                               = 0xBADD,
     SMSG_BF_MGR_ENTERING                              = 0xBADD,
diff --git a/src/server/game/Server/WorldSession.h b/src/server/game/Server/WorldSession.h
index fcfef949e75..635d2a16ce1 100644
--- a/src/server/game/Server/WorldSession.h
+++ b/src/server/game/Server/WorldSession.h
@@ -94,9 +94,8 @@ namespace WorldPackets
     {
         class AuctionHelloRequest;
         class AuctionListBidderItems;
-        class AuctionListItems;
+        class AuctionBrowseQuery;
         class AuctionListOwnerItems;
-        class AuctionListPendingSales;
         class AuctionPlaceBid;
         class AuctionRemoveItem;
         class AuctionReplicateItems;
@@ -1379,13 +1378,12 @@ class TC_GAME_API WorldSession
         void HandleUnacceptTradeOpcode(WorldPackets::Trade::UnacceptTrade& unacceptTrade);
 
         void HandleAuctionHelloOpcode(WorldPackets::AuctionHouse::AuctionHelloRequest& packet);
-        void HandleAuctionListItems(WorldPackets::AuctionHouse::AuctionListItems& packet);
+        void HandleAuctionListItems(WorldPackets::AuctionHouse::AuctionBrowseQuery& browseQuery);
         void HandleAuctionListBidderItems(WorldPackets::AuctionHouse::AuctionListBidderItems& packet);
         void HandleAuctionSellItem(WorldPackets::AuctionHouse::AuctionSellItem& packet);
         void HandleAuctionRemoveItem(WorldPackets::AuctionHouse::AuctionRemoveItem& packet);
         void HandleAuctionListOwnerItems(WorldPackets::AuctionHouse::AuctionListOwnerItems& packet);
         void HandleAuctionPlaceBid(WorldPackets::AuctionHouse::AuctionPlaceBid& packet);
-        void HandleAuctionListPendingSales(WorldPackets::AuctionHouse::AuctionListPendingSales& packet);
         void HandleReplicateItems(WorldPackets::AuctionHouse::AuctionReplicateItems& packet);
 
         // Bank