fix(exchange): confirm/cancel packets are dropped once a trade is open

Directory.Packages.props

@@ -43,7 +43,7 @@
     <PackageVersion Include="NosCore.Analyzers" Version="2.0.0" />
     <PackageVersion Include="NosCore.Dao" Version="5.0.0" />
     <PackageVersion Include="NosCore.Networking" Version="8.0.1" />
-    <PackageVersion Include="NosCore.Packets" Version="21.1.2" />
+    <PackageVersion Include="NosCore.Packets" Version="21.1.3" />
     <PackageVersion Include="NosCore.PathFinder" Version="2.1.0" />
     <PackageVersion Include="NosCore.Shared" Version="6.0.2" />
     <PackageVersion Include="Npgsql.EntityFrameworkCore.PostgreSQL" Version="10.0.3" />

src/NosCore.GameObject/Services/ExchangeService/ExchangeService.cs

@@ -333,7 +333,7 @@ bool IsFullTransfer
                 items.Add(new KeyValuePair<long, IvnPacket>(transfer.SessionId,
                     (sourceItem ?? transfer.OriginalItem).GeneratePocketChange((PocketType)transfer.OriginalItem.Type, transfer.OriginalItem.Slot)));
                 items.Add(new KeyValuePair<long, IvnPacket>(transfer.TargetId,
-                    transfer.OriginalItem.GeneratePocketChange((PocketType)addedItem.Item.Type, addedItem.Item.Slot)));
+                    addedItem.Item.GeneratePocketChange((PocketType)addedItem.Item.Type, addedItem.Item.Slot)));
             }
 
             return items;

src/NosCore.PacketHandlers/Exchange/ExcListPacketHandler.cs

@@ -39,7 +39,7 @@ public override async Task ExecuteAsync(ExcListPacket packet, ClientSession clie
                 (s.VisualId == exchangeService.GetTargetId(clientSession.Character.VisualId)) &&
                 (s.MapInstanceId == clientSession.Character.MapInstanceId), out var target);
 
-            if ((packet.SubPackets!.Count > 0) && hasTarget)
+            if ((packet.SubPackets?.Count > 0) && hasTarget)
             {
                 byte i = 0;
                 foreach (var value in packet.SubPackets)

src/NosCore.PacketHandlers/Exchange/ExchangeRequestPacketHandler.cs

@@ -67,7 +67,7 @@ await clientSession.SendPacketAsync(new Infoi2Packet
                         return;
                     }
 
-                    if (!hasTarget || target.ExchangeBlocked)
+                    if (!hasTarget || target.ExchangeBlocked || (target.VisualId == clientSession.Character.VisualId))
                     {
                         await clientSession.SendPacketAsync(new Infoi2Packet
                         {
@@ -184,7 +184,7 @@ await clientSession.SendPacketAsync(new InfoiPacket
 
                     var success = exchangeService.ValidateExchange(clientSession, exchangeTarget);
 
-                    if (success.Item1 == ExchangeResultType.Success)
+                    if (success.Item1 == ExchangeResultType.Failure)
                     {
                         foreach (var infoPacket in success.Item2!)
                         {

test/NosCore.GameObject.Tests/Services/ExchangeService/ExchangeServiceTests.cs

@@ -19,6 +19,7 @@
 using NosCore.Packets.ClientPackets.Inventory;
 using NosCore.Packets.Enumerations;
 using NosCore.Packets.Interfaces;
+using NosCore.Packets.ServerPackets.Inventory;
 using NosCore.Packets.ServerPackets.UI;
 using NosCore.Tests.Shared;
 using Microsoft.Extensions.Logging.Abstractions;
@@ -359,5 +360,31 @@ public void AnOfferedItemThatLeftTheInventoryDoesNotReachTheOtherSide()
             Assert.AreEqual(0, itemList.Count, "a vanished offer must not transfer");
             Assert.AreEqual(0, receiver.Count, "the receiver must not gain a duplicate");
         }
+
+        [TestMethod]
+        public void ProcessExchangeNotifiesReceiverWithTheirActualMergedAmount()
+        {
+            IInventoryService giver =
+                new GameObject.Services.InventoryService.InventoryService(new List<ItemDto> { new Item { VNum = 1012, Type = NoscorePocketType.Main } },
+                    WorldConfiguration!, NullLogger<NosCore.GameObject.Services.InventoryService.InventoryService>.Instance);
+            IInventoryService receiver =
+                new GameObject.Services.InventoryService.InventoryService(new List<ItemDto> { new Item { VNum = 1012, Type = NoscorePocketType.Main } },
+                    WorldConfiguration!, NullLogger<NosCore.GameObject.Services.InventoryService.InventoryService>.Instance);
+
+            var offered = giver.AddItemToPocket(InventoryItemInstance.Create(ItemProvider!.Create(1012, 5), 0))!.First();
+            receiver.AddItemToPocket(InventoryItemInstance.Create(ItemProvider.Create(1012, 4), 0));
+
+            ExchangeProvider!.OpenExchange(1, 2);
+            // Offering less than the full stack (2 of 5) forces the partial-transfer branch,
+            // which mutates the giver's own item object in place - this used to leak into the
+            // receiver's notification packet.
+            ExchangeProvider.AddItems(1, offered, 2);
+
+            var itemList = ExchangeProvider.ProcessExchange(1, 2, giver, receiver);
+
+            var receiverPacket = itemList.First(s => s.Key == 2).Value;
+            var receiverAmount = receiverPacket.IvnSubPackets!.First()!.RareAmount;
+            Assert.AreEqual((short)6, receiverAmount, "the receiver must be notified of their true merged total (4 + 2), not the giver's remaining balance");
+        }
     }
 }

test/NosCore.PacketHandlers.Tests/Exchange/ExcListPacketHandlerTests.cs

@@ -104,6 +104,28 @@ public async Task SettingValidGoldShouldUpdateExchange()
                 .ExecuteAsync();
         }
 
+        [TestMethod]
+        public async Task GoldOnlyOfferShouldNotCloseExchange()
+        {
+            await new Spec("Gold only offer should not close exchange")
+                .Given(CharacterHasGold)
+                .And(ExchangeIsOpenWithTarget)
+                .WhenAsync(OfferingOnlyGold)
+                .Then(ExchangeShouldNotBeClosed)
+                .ExecuteAsync();
+        }
+
+        [TestMethod]
+        public async Task GoldOnlyOfferShouldSetGold()
+        {
+            await new Spec("Gold only offer should set gold")
+                .Given(CharacterHasGold)
+                .And(ExchangeIsOpenWithTarget)
+                .WhenAsync(OfferingOnlyGold)
+                .Then(ExchangeGoldShouldBeSet)
+                .ExecuteAsync();
+        }
+
         private void CharacterHasNoGold()
         {
             Session.Character.Gold = 0;
@@ -179,11 +201,26 @@ await Handler.ExecuteAsync(new ExcListPacket
             }, Session);
         }
 
+        private async Task OfferingOnlyGold()
+        {
+            await Handler.ExecuteAsync(new ExcListPacket
+            {
+                Gold = 5000,
+                BankGold = 0,
+                SubPackets = null
+            }, Session);
+        }
+
         private void ExchangeGoldShouldNotBeSet()
         {
             ExchangeService.Verify(x => x.SetGold(It.IsAny<long>(), It.IsAny<long>(), It.IsAny<long>()), Times.Never);
         }
 
+        private void ExchangeShouldNotBeClosed()
+        {
+            ExchangeService.Verify(x => x.CloseExchange(It.IsAny<long>(), It.IsAny<ExchangeResultType>()), Times.Never);
+        }
+
         private void ExchangeGoldShouldBeSet()
         {
             var characterId = Session.Character.CharacterId;

test/NosCore.PacketHandlers.Tests/Exchange/ExchangeRequestPacketHandlerTests.cs

@@ -86,6 +86,26 @@ public async Task RequestingExchangeWhenTargetBlocksExchangeShouldFail()
                 .ExecuteAsync();
         }
 
+        [TestMethod]
+        public async Task RequestingExchangeWithSelfShouldFail()
+        {
+            await new Spec("Requesting exchange with self should fail")
+                .Given(TargetIsSelf)
+                .WhenAsync(RequestingExchangeWithSelf)
+                .Then(ShouldReceiveBlockingTradesMessage)
+                .ExecuteAsync();
+        }
+
+        [TestMethod]
+        public async Task RequestingExchangeWithSelfShouldNotOpenExchange()
+        {
+            await new Spec("Requesting exchange with self should not open an exchange")
+                .Given(TargetIsSelf)
+                .WhenAsync(RequestingExchangeWithSelf)
+                .Then(NoExchangeShouldBeOpened)
+                .ExecuteAsync();
+        }
+
         [TestMethod]
         public async Task RequestingExchangeWithBlacklistedPlayerShouldFail()
         {
@@ -128,6 +148,12 @@ private void TargetBlocksExchange()
             ExchangeService.Setup(x => x.CheckExchange(It.IsAny<long>())).Returns(false);
         }
 
+        private void TargetIsSelf()
+        {
+            Session.Character.MapInstance = TestHelpers.Instance.MapInstanceAccessorService.GetBaseMapById(1)!;
+            ExchangeService.Setup(x => x.CheckExchange(It.IsAny<long>())).Returns(false);
+        }
+
         private void TargetIsBlacklisted()
         {
             Session.Character.MapInstance = TestHelpers.Instance.MapInstanceAccessorService.GetBaseMapById(1)!;
@@ -161,6 +187,15 @@ await Handler.ExecuteAsync(new ExchangeRequestPacket
             }, Session);
         }
 
+        private async Task RequestingExchangeWithSelf()
+        {
+            await Handler.ExecuteAsync(new ExchangeRequestPacket
+            {
+                RequestType = RequestExchangeType.Requested,
+                VisualId = Session.Character.VisualId
+            }, Session);
+        }
+
         private async Task CancellingExchange()
         {
             await Handler.ExecuteAsync(new ExchangeRequestPacket