diff --git a/src/api/inventory/GroupItem.ts b/src/api/inventory/GroupItem.ts
index d229200e..9a16c36d 100644
--- a/src/api/inventory/GroupItem.ts
+++ b/src/api/inventory/GroupItem.ts
@@ -281,8 +281,8 @@ export class GroupItem
 
         while(index < items.length)
         {
-            const item      = items[index];
-            const locked    = (itemIds.indexOf(item.ref) >= 0);
+            const item = items[index];
+            const locked = (itemIds.indexOf(item.ref) >= 0);
 
             if(item.locked !== locked)
             {
diff --git a/src/api/inventory/TradeUserData.ts b/src/api/inventory/TradeUserData.ts
index b0b337b3..b62b32f9 100644
--- a/src/api/inventory/TradeUserData.ts
+++ b/src/api/inventory/TradeUserData.ts
@@ -6,10 +6,9 @@ export class TradeUserData
     constructor(
         public userId: number = -1,
         public userName: string = '',
-        public userItems: AdvancedMap<string, GroupItem> = null,
+        public userItems: AdvancedMap<string, GroupItem> = new AdvancedMap(),
         public itemCount: number = 0,
         public creditsCount: number = 0,
         public accepts: boolean = false,
-        public canTrade: boolean = false,
-        public items: AdvancedMap<string, GroupItem> = new AdvancedMap()) {}
+        public canTrade: boolean = false) {}
 }
diff --git a/src/components/catalog/views/page/layout/CatalogLayoutBadgeDisplayView.tsx b/src/components/catalog/views/page/layout/CatalogLayoutBadgeDisplayView.tsx
index f94dc1c9..97860eeb 100644
--- a/src/components/catalog/views/page/layout/CatalogLayoutBadgeDisplayView.tsx
+++ b/src/components/catalog/views/page/layout/CatalogLayoutBadgeDisplayView.tsx
@@ -1,10 +1,6 @@
 import { FC } from 'react';
 import { LocalizeText } from '../../../../../api';
-import { Base } from '../../../../../common/Base';
-import { Column } from '../../../../../common/Column';
-import { Flex } from '../../../../../common/Flex';
-import { Grid } from '../../../../../common/Grid';
-import { Text } from '../../../../../common/Text';
+import { Base, Column, Flex, Grid, Text } from '../../../../../common';
 import { useCatalogContext } from '../../../CatalogContext';
 import { CatalogBadgeSelectorWidgetView } from '../widgets/CatalogBadgeSelectorWidgetView';
 import { CatalogFirstProductSelectorWidgetView } from '../widgets/CatalogFirstProductSelectorWidgetView';
diff --git a/src/components/catalog/views/page/widgets/CatalogBadgeSelectorWidgetView.tsx b/src/components/catalog/views/page/widgets/CatalogBadgeSelectorWidgetView.tsx
index 47b589e5..732dfad2 100644
--- a/src/components/catalog/views/page/widgets/CatalogBadgeSelectorWidgetView.tsx
+++ b/src/components/catalog/views/page/widgets/CatalogBadgeSelectorWidgetView.tsx
@@ -1,6 +1,5 @@
 import { StringDataType } from '@nitrots/nitro-renderer';
 import { FC, useEffect, useMemo, useState } from 'react';
-import { IBadgeItem } from '../../../../../api';
 import { AutoGrid, AutoGridProps, LayoutBadgeImageView, LayoutGridItem } from '../../../../../common';
 import { useSharedInventoryBadges } from '../../../../../hooks';
 import { useCatalogContext } from '../../../CatalogContext';
@@ -15,20 +14,20 @@ interface CatalogBadgeSelectorWidgetViewProps extends AutoGridProps
 export const CatalogBadgeSelectorWidgetView: FC<CatalogBadgeSelectorWidgetViewProps> = props =>
 {
     const { columnCount = 5, ...rest } = props;
-    const [ currentBadge, setCurrentBadge ] = useState<IBadgeItem>(null);
+    const [ currentBadgeCode, setCurrentBadgeCode ] = useState<string>(null);
     const { currentOffer = null, setPurchaseOptions = null } = useCatalogContext();
-    const { badges = [] } = useSharedInventoryBadges();
+    const { badgeCodes = [] } = useSharedInventoryBadges();
 
     const previewStuffData = useMemo(() =>
     {
-        if(!currentBadge) return null;
+        if(!currentBadgeCode) return null;
 
         const stuffData = new StringDataType();
 
-        stuffData.setValue([ '0', currentBadge.badgeCode, '', '' ]);
+        stuffData.setValue([ '0', currentBadgeCode, '', '' ]);
 
         return stuffData;
-    }, [ currentBadge ]);
+    }, [ currentBadgeCode ]);
 
     useEffect(() =>
     {
@@ -48,11 +47,11 @@ export const CatalogBadgeSelectorWidgetView: FC<CatalogBadgeSelectorWidgetViewPr
 
     return (
         <AutoGrid columnCount={ columnCount } { ...rest }>
-            { badges && (badges.length > 0) && badges.map((badge, index) =>
+            { badgeCodes && (badgeCodes.length > 0) && badgeCodes.map((badgeCode, index) =>
                 {
                     return (
-                        <LayoutGridItem key={ index } itemActive={ (currentBadge === badge) } onClick={ event => setCurrentBadge(badge) }> 
-                            <LayoutBadgeImageView badgeCode={ badge.badgeCode } />
+                        <LayoutGridItem key={ index } itemActive={ (currentBadgeCode === badgeCode) } onClick={ event => setCurrentBadgeCode(badgeCode) }> 
+                            <LayoutBadgeImageView badgeCode={ badgeCode } />
                         </LayoutGridItem>
                     );
                 }) }
diff --git a/src/components/inventory/InventoryView.tsx b/src/components/inventory/InventoryView.tsx
index fd862598..09b958a4 100644
--- a/src/components/inventory/InventoryView.tsx
+++ b/src/components/inventory/InventoryView.tsx
@@ -1,10 +1,9 @@
-import { BadgePointLimitsEvent, ILinkEventTracker, IRoomSession, RoomEngineObjectEvent, RoomEngineObjectPlacedEvent, RoomPreviewer, RoomSessionEvent, TradingOpenComposer } from '@nitrots/nitro-renderer';
+import { BadgePointLimitsEvent, ILinkEventTracker, IRoomSession, RoomEngineObjectEvent, RoomEngineObjectPlacedEvent, RoomPreviewer, RoomSessionEvent } from '@nitrots/nitro-renderer';
 import { FC, useCallback, useEffect, useState } from 'react';
-import { AddEventLinkTracker, GetLocalization, GetRoomEngine, LocalizeText, RemoveLinkEventTracker, SendMessageComposer, UnseenItemCategory } from '../../api';
+import { AddEventLinkTracker, GetLocalization, GetRoomEngine, LocalizeText, RemoveLinkEventTracker, UnseenItemCategory } from '../../api';
 import { isObjectMoverRequested, setObjectMoverRequested } from '../../api/inventory/InventoryUtilities';
 import { NitroCardContentView, NitroCardHeaderView, NitroCardTabsItemView, NitroCardTabsView, NitroCardView } from '../../common';
-import { InventoryTradeRequestEvent } from '../../events';
-import { UseMessageEventHook, UseRoomEngineEvent, UseRoomSessionManagerEvent, useSharedInventoryUnseenTracker, UseUiEvent } from '../../hooks';
+import { UseMessageEventHook, UseRoomEngineEvent, UseRoomSessionManagerEvent, useSharedInventoryTrade, useSharedInventoryUnseenTracker } from '../../hooks';
 import { InventoryBadgeView } from './views/InventoryBadgeView';
 import { InventoryBotView } from './views/InventoryBotView';
 import { InventoryFurnitureView } from './views/InventoryFurnitureView';
@@ -24,40 +23,15 @@ export const InventoryView: FC<{}> = props =>
     const [ currentTab, setCurrentTab ] = useState<string>(TABS[0]);
     const [ roomSession, setRoomSession ] = useState<IRoomSession>(null);
     const [ roomPreviewer, setRoomPreviewer ] = useState<RoomPreviewer>(null);
+    const { isTrading = false, stopTrading = null } = useSharedInventoryTrade();
     const { getCount = null, resetCategory = null } = useSharedInventoryUnseenTracker();
 
-    const close = useCallback(() =>
+    const close = () =>
     {
-        // close the trade
-        // if(furnitureState.tradeData)
-        // {
-        //     switch(furnitureState.tradeData.state)
-        //     {
-        //         case TradeState.TRADING_STATE_RUNNING:
-        //             SendMessageComposer(new TradingCloseComposer());
-        //             return;
-        //         default:
-        //             SendMessageComposer(new TradingCancelComposer());
-        //             return;
-        //     }
-        // }
-        
+        if(isTrading) stopTrading();
+
         setIsVisible(false);
-    }, []);
-
-    const onInventoryTradeRequestEvent = useCallback((event: InventoryTradeRequestEvent) =>
-    {
-        switch(event.type)
-        {
-            case InventoryTradeRequestEvent.REQUEST_TRADE: {
-                const tradeEvent = (event as InventoryTradeRequestEvent);
-
-                SendMessageComposer(new TradingOpenComposer(tradeEvent.objectId));
-            }
-        }
-    }, []);
-
-    UseUiEvent(InventoryTradeRequestEvent.REQUEST_TRADE, onInventoryTradeRequestEvent);
+    }
 
     const onRoomEngineObjectPlacedEvent = useCallback((event: RoomEngineObjectPlacedEvent) =>
     {
@@ -143,13 +117,8 @@ export const InventoryView: FC<{}> = props =>
 
     useEffect(() =>
     {
-        if(!isVisible)
-        {
-            // if trading show it
-        }
-    }, [ isVisible ]);
-
-    const isTrading = false;
+        if(!isVisible && isTrading) setIsVisible(true);
+    }, [ isVisible, isTrading ]);
 
     if(!isVisible) return null;
 
diff --git a/src/components/inventory/views/InventoryBadgeView.tsx b/src/components/inventory/views/InventoryBadgeView.tsx
index a5ba05f1..b1dea24d 100644
--- a/src/components/inventory/views/InventoryBadgeView.tsx
+++ b/src/components/inventory/views/InventoryBadgeView.tsx
@@ -1,16 +1,16 @@
 import { FC, useEffect } from 'react';
-import { IBadgeItem, LocalizeBadgeName, LocalizeText, UnseenItemCategory } from '../../../api';
+import { LocalizeBadgeName, LocalizeText, UnseenItemCategory } from '../../../api';
 import { AutoGrid, Button, Column, Flex, Grid, LayoutBadgeImageView, LayoutGridItem, Text } from '../../../common';
 import { useSharedInventoryBadges, useSharedInventoryUnseenTracker } from '../../../hooks';
 
 export const InventoryBadgeView: FC<{}> = props =>
 {
-    const { badges = [], activeBadges = [], selectedBadge = null, isWearingBadge = null, canWearBadges = null, toggleBadge = null, selectBadge = null } = useSharedInventoryBadges();
+    const { badgeCodes = [], activeBadgeCodes = [], selectedBadgeCode = null, isWearingBadge = null, canWearBadges = null, toggleBadge = null, selectBadge = null, getBadgeId = null } = useSharedInventoryBadges();
     const { getCount = null, resetCategory = null, isUnseen = null, removeUnseen = null } = useSharedInventoryUnseenTracker();
 
     useEffect(() =>
     {
-        if(!badges || !badges.length) return;
+        if(!badgeCodes || !badgeCodes.length) return;
         
         return () =>
         {
@@ -20,23 +20,24 @@ export const InventoryBadgeView: FC<{}> = props =>
 
             resetCategory(UnseenItemCategory.BADGE);
         }
-    }, [ badges, getCount, resetCategory ]);
+    }, [ badgeCodes, getCount, resetCategory ]);
 
-    const InventoryBadgeItemView: FC<{ badge: IBadgeItem }> = props =>
+    const InventoryBadgeItemView: FC<{ badgeCode: string }> = props =>
     {
-        const { badge = null, children = null, ...rest } = props;
-        const unseen = isUnseen(UnseenItemCategory.BADGE, badge.id);
+        const { badgeCode = null, children = null, ...rest } = props;
+        const badgeId = getBadgeId(badgeCode);
+        const unseen = isUnseen(UnseenItemCategory.BADGE, badgeId);
 
         const select = () =>
         {
-            selectBadge(badge);
+            selectBadge(badgeCode);
 
-            if(unseen) removeUnseen(UnseenItemCategory.BADGE, badge.id);
+            if(unseen) removeUnseen(UnseenItemCategory.BADGE, badgeId);
         }
 
         return (
-            <LayoutGridItem itemActive={ (selectedBadge === badge) } itemUnseen={ unseen } onMouseDown={ select } { ...rest }> 
-                <LayoutBadgeImageView badgeCode={ badge.badgeCode } />
+            <LayoutGridItem itemActive={ (selectedBadgeCode === badgeCode) } itemUnseen={ unseen } onMouseDown={ select } { ...rest }> 
+                <LayoutBadgeImageView badgeCode={ badgeCode } />
                 { children }
             </LayoutGridItem>
         );
@@ -46,11 +47,11 @@ export const InventoryBadgeView: FC<{}> = props =>
         <Grid>
             <Column size={ 7 } overflow="hidden">
                 <AutoGrid columnCount={ 4 }>
-                    { badges && (badges.length > 0) && badges.map((badge, index) =>
+                    { badgeCodes && (badgeCodes.length > 0) && badgeCodes.map((badgeCode, index) =>
                         {
-                            if(activeBadges.indexOf(badge) >= 0) return null;
+                            if(activeBadgeCodes.indexOf(badgeCode) >= 0) return null;
 
-                            return <InventoryBadgeItemView key={ index } badge={ badge } />
+                            return <InventoryBadgeItemView key={ index } badgeCode={ badgeCode } />
                         }) }
                 </AutoGrid>
             </Column>
@@ -58,16 +59,16 @@ export const InventoryBadgeView: FC<{}> = props =>
                 <Column overflow="hidden" gap={ 2 }>
                     <Text>{ LocalizeText('inventory.badges.activebadges') }</Text>
                     <AutoGrid columnCount={ 3 }>
-                        { activeBadges && (activeBadges.length > 0) && activeBadges.map((badge, index) => <InventoryBadgeItemView key={ index } badge={ badge } />) }
+                        { activeBadgeCodes && (activeBadgeCodes.length > 0) && activeBadgeCodes.map((badgeCode, index) => <InventoryBadgeItemView key={ index } badgeCode={ badgeCode } />) }
                     </AutoGrid>
                 </Column>
-                { !!selectedBadge &&
+                { !!selectedBadgeCode &&
                     <Column grow justifyContent="end" gap={ 2 }>
                         <Flex alignItems="center" gap={ 2 }>
-                            <LayoutBadgeImageView shrink badgeCode={ selectedBadge.badgeCode } />
-                            <Text>{ LocalizeBadgeName(selectedBadge.badgeCode) }</Text>
+                            <LayoutBadgeImageView shrink badgeCode={ selectedBadgeCode } />
+                            <Text>{ LocalizeBadgeName(selectedBadgeCode) }</Text>
                         </Flex>
-                        <Button variant={ (isWearingBadge(selectedBadge) ? 'danger' : 'success') } disabled={ !isWearingBadge(selectedBadge) && !canWearBadges() } onClick={ event => toggleBadge(selectedBadge) }>{ LocalizeText(isWearingBadge(selectedBadge) ? 'inventory.badges.clearbadge' : 'inventory.badges.wearbadge') }</Button>
+                        <Button variant={ (isWearingBadge(selectedBadgeCode) ? 'danger' : 'success') } disabled={ !isWearingBadge(selectedBadgeCode) && !canWearBadges() } onClick={ event => toggleBadge(selectedBadgeCode) }>{ LocalizeText(isWearingBadge(selectedBadgeCode) ? 'inventory.badges.clearbadge' : 'inventory.badges.wearbadge') }</Button>
                     </Column> }
             </Column>
         </Grid>
diff --git a/src/components/inventory/views/InventoryTradeView.tsx b/src/components/inventory/views/InventoryTradeView.tsx
index a36e0731..99086a93 100644
--- a/src/components/inventory/views/InventoryTradeView.tsx
+++ b/src/components/inventory/views/InventoryTradeView.tsx
@@ -26,9 +26,9 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
 
     const canTradeItem = (isWallItem: boolean, spriteId: number, category: number, groupable: boolean, stuffData: IObjectData) =>
     {
-        if(!ownUser || ownUser.accepts || !ownUser.items) return false;
+        if(!ownUser || ownUser.accepts || !ownUser.userItems) return false;
 
-        if(ownUser.items.length < MAX_ITEMS_TO_TRADE) return true;
+        if(ownUser.userItems.length < MAX_ITEMS_TO_TRADE) return true;
 
         if(!groupable) return false;
 
@@ -50,7 +50,7 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
             }
         }
 
-        return !!ownUser.items.getValue(type);
+        return !!ownUser.userItems.getValue(type);
     }
 
     const attemptItemOffer = (count: number) =>
@@ -71,7 +71,7 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
             if(!coreItem) coreItem = item;
         }
 
-        const ownItemCount = ownUser.items.length;
+        const ownItemCount = ownUser.userItems.length;
 
         if((ownItemCount + itemIds.length) <= 1500)
         {
@@ -130,12 +130,7 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
                 {
                     const newValue = (prevValue - 1);
 
-                    if(newValue === 0)
-                    {
-                        setTradeState(TradeState.TRADING_STATE_CONFIRMING);
-
-                        clearInterval(interval);
-                    }
+                    if(newValue === 0) clearInterval(interval);
 
                     return newValue;
                 });
@@ -144,6 +139,15 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
         return () => clearInterval(interval);
     }, [ tradeState, setTradeState ]);
 
+    useEffect(() =>
+    {
+        if(countdownTick !== 0) return;
+
+        setTradeState(TradeState.TRADING_STATE_CONFIRMING);
+    }, [ countdownTick, setTradeState ]);
+
+    if((tradeState === TradeState.TRADING_STATE_READY) || !ownUser || !otherUser) return null;
+
     return (
         <Grid>
             <Column size={ 4 } overflow="hidden">
@@ -179,7 +183,7 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
                         <AutoGrid columnCount={ 3 }>
                             { Array.from(Array(MAX_ITEMS_TO_TRADE), (e, i) =>
                                 {
-                                    const item = (ownUser.items.getWithIndex(i) || null);
+                                    const item = (ownUser.userItems.getWithIndex(i) || null);
 
                                     if(!item) return <LayoutGridItem key={ i } />;
 
@@ -205,7 +209,7 @@ export const InventoryTradeView: FC<InventoryTradeViewProps> = props =>
                         <AutoGrid columnCount={ 3 }>
                             { Array.from(Array(MAX_ITEMS_TO_TRADE), (e, i) =>
                                 {
-                                    const item = (otherUser.items.getWithIndex(i) || null);
+                                    const item = (otherUser.userItems.getWithIndex(i) || null);
 
                                     if(!item) return <LayoutGridItem key={ i } />;
 
diff --git a/src/hooks/inventory/common/TradingUtilities.ts b/src/hooks/inventory/common/TradingUtilities.ts
index 34868be9..e744f2a7 100644
--- a/src/hooks/inventory/common/TradingUtilities.ts
+++ b/src/hooks/inventory/common/TradingUtilities.ts
@@ -9,40 +9,41 @@ export const parseTradeItems = (items: ItemDataStructure[]) =>
     const existingItems = new AdvancedMap<string, GroupItem>();
     const totalItems = items.length;
 
-    if(!totalItems) return null;
-
-    for(const item of items)
+    if(totalItems)
     {
-        const spriteId = item.spriteId;
-        const category = item.category;
-
-        let name = (item.furniType + spriteId);
-
-        if(!item.isGroupable || isExternalImage(spriteId))
+        for(const item of items)
         {
-            name = ('itemid' + item.itemId);
+            const spriteId = item.spriteId;
+            const category = item.category;
+    
+            let name = (item.furniType + spriteId);
+    
+            if(!item.isGroupable || isExternalImage(spriteId))
+            {
+                name = ('itemid' + item.itemId);
+            }
+    
+            if(item.category === FurniCategory.POSTER)
+            {
+                name = (item.itemId + 'poster' + item.stuffData.getLegacyString());
+            }
+    
+            else if(item.category === FurniCategory.GUILD_FURNI)
+            {
+                name = '';
+            }
+    
+            let groupItem = ((item.isGroupable && !isExternalImage(item.spriteId)) ? existingItems.getValue(name) : null);
+    
+            if(!groupItem)
+            {
+                groupItem = createGroupItem(spriteId, category, item.stuffData);
+    
+                existingItems.add(name, groupItem);
+            }
+    
+            groupItem.push(new FurnitureItem(item));
         }
-
-        if(item.category === FurniCategory.POSTER)
-        {
-            name = (item.itemId + 'poster' + item.stuffData.getLegacyString());
-        }
-
-        else if(item.category === FurniCategory.GUILD_FURNI)
-        {
-            name = '';
-        }
-
-        let groupItem = ((item.isGroupable && !isExternalImage(item.spriteId)) ? existingItems.getValue(name) : null);
-
-        if(!groupItem)
-        {
-            groupItem = createGroupItem(spriteId, category, item.stuffData);
-
-            existingItems.add(name, groupItem);
-        }
-
-        groupItem.push(new FurnitureItem(item));
     }
 
     return existingItems;
diff --git a/src/hooks/inventory/useSharedInventoryBadges.ts b/src/hooks/inventory/useSharedInventoryBadges.ts
index 539f1b4e..e9c2593a 100644
--- a/src/hooks/inventory/useSharedInventoryBadges.ts
+++ b/src/hooks/inventory/useSharedInventoryBadges.ts
@@ -2,34 +2,35 @@ import { BadgeReceivedEvent, BadgesEvent, RequestBadgesComposer, SetActivatedBad
 import { useCallback, useEffect, useState } from 'react';
 import { useBetween } from 'use-between';
 import { BatchUpdates, UseMessageEventHook } from '..';
-import { GetConfiguration, IBadgeItem, SendMessageComposer } from '../../api';
+import { GetConfiguration, SendMessageComposer } from '../../api';
 import { useSharedVisibility } from '../useSharedVisibility';
 
 const useInventoryBadges = () =>
 {
     const [ isVisible, setIsVisible ] = useState(false);
     const [ needsUpdate, setNeedsUpdate ] = useState(true);
-    const [ badges, setBadges ] = useState<IBadgeItem[]>([]);
-    const [ activeBadges, setActiveBadges ] = useState<IBadgeItem[]>([]);
-    const [ selectedBadge, setSelectedBadge ] = useState<IBadgeItem>(null);
+    const [ badgeCodes, setBadgeCodes ] = useState<string[]>([]);
+    const [ badgeIds, setBadgeIds ] = useState<number[]>([]);
+    const [ activeBadgeCodes, setActiveBadgeCodes ] = useState<string[]>([]);
+    const [ selectedBadgeCode, setSelectedBadgeCode ] = useState<string>(null);
 
     const maxBadgeCount = GetConfiguration<number>('user.badges.max.slots', 5);
-    const isWearingBadge = (badge: IBadgeItem) => (activeBadges.indexOf(badge) >= 0);
-    const canWearBadges = () => (activeBadges.length < maxBadgeCount);
+    const isWearingBadge = (badgeCode: string) => (activeBadgeCodes.indexOf(badgeCode) >= 0);
+    const canWearBadges = () => (activeBadgeCodes.length < maxBadgeCount);
 
-    const toggleBadge = (badge: IBadgeItem) =>
+    const toggleBadge = (badgeCode: string) =>
     {
-        setActiveBadges(prevValue =>
+        setActiveBadgeCodes(prevValue =>
             {
                 const newValue = [ ...prevValue ];
 
-                const index = newValue.indexOf(badge);
+                const index = newValue.indexOf(badgeCode);
 
                 if(index === -1)
                 {
                     if(!canWearBadges()) return prevValue;
 
-                    newValue.push(badge);
+                    newValue.push(badgeCode);
                 }
                 else
                 {
@@ -38,7 +39,7 @@ const useInventoryBadges = () =>
 
                 const composer = new SetActivatedBadgesComposer();
 
-                for(let i = 0; i < maxBadgeCount; i++) composer.addActivatedBadge((newValue[i] && newValue[i].badgeCode) || null);
+                for(let i = 0; i < maxBadgeCount; i++) composer.addActivatedBadge(newValue[i] || null);
 
                 SendMessageComposer(composer);
 
@@ -46,11 +47,20 @@ const useInventoryBadges = () =>
             });
     }
 
-    const selectBadge = (badge: IBadgeItem) =>
+    const selectBadge = (badgeCode: string) =>
     {
-        if(badges.indexOf(badge) === -1) return;
+        if(badgeCodes.indexOf(badgeCode) === -1) return;
 
-        setSelectedBadge(badge);
+        setSelectedBadgeCode(badgeCode);
+    }
+
+    const getBadgeId = (badgeCode: string) =>
+    {
+        const index = badgeCodes.indexOf(badgeCode);
+
+        if(index === -1) return 0;
+
+        return (badgeIds[index] || 0);
     }
 
     const onBadgesEvent = useCallback((event: BadgesEvent) =>
@@ -59,25 +69,14 @@ const useInventoryBadges = () =>
 
         BatchUpdates(() =>
         {
-            setBadges(prevValue =>
-                {
-                    const newValue: IBadgeItem[] = [];
-                    const badgeCodes = parser.getAllBadgeCodes();
+            const newBadgeCodes = parser.getAllBadgeCodes();
+            const newBadgeIds: number[] = [];
 
-                    for(const badgeCode of badgeCodes) newValue.push({ id: parser.getBadgeId(badgeCode), badgeCode });
+            for(const newBadgeCode of newBadgeCodes) newBadgeIds.push(parser.getBadgeId(newBadgeCode));
 
-                    return newValue;
-                });
-
-            setActiveBadges(prevValue =>
-                {
-                    const newValue: IBadgeItem[] = [];
-                    const badgeCodes = parser.getActiveBadgeCodes();
-
-                    for(const badgeCode of badgeCodes) newValue.push({ id: parser.getBadgeId(badgeCode), badgeCode });
-
-                    return newValue;
-                });
+            setBadgeCodes(newBadgeCodes);
+            setBadgeIds(newBadgeIds);
+            setActiveBadgeCodes(parser.getActiveBadgeCodes());
         });
     }, []);
 
@@ -87,33 +86,45 @@ const useInventoryBadges = () =>
     {
         const parser = event.getParser();
 
-        setBadges(prevValue =>
-            {
-                const newValue = [ ...prevValue ];
+        BatchUpdates(() =>
+        {
+            setBadgeCodes(prevValue =>
+                {
+                    const newValue = [ ...prevValue ];
 
-                newValue.push({ id: parser.badgeId, badgeCode: parser.badgeCode });
-
-                return newValue;
-            });
+                    newValue.push(parser.badgeCode);
+    
+                    return newValue;
+                });
+    
+            setBadgeIds(prevValue =>
+                {
+                    const newValue = [ ...prevValue ];
+    
+                    newValue.push(parser.badgeId);
+    
+                    return newValue;
+                })
+        });
     }, []);
 
     UseMessageEventHook(BadgeReceivedEvent, onBadgeReceivedEvent);
 
     useEffect(() =>
     {
-        if(!badges || !badges.length) return;
+        if(!badgeCodes || !badgeCodes.length) return;
 
-        setSelectedBadge(prevValue =>
+        setSelectedBadgeCode(prevValue =>
             {
                 let newValue = prevValue;
 
-                if(newValue && (badges.indexOf(newValue) === -1)) newValue = null;
+                if(newValue && (badgeCodes.indexOf(newValue) === -1)) newValue = null;
 
-                if(!newValue) newValue = badges[0];
+                if(!newValue) newValue = badgeCodes[0];
 
                 return newValue;
             });
-    }, [ badges ]);
+    }, [ badgeCodes ]);
 
     useEffect(() =>
     {
@@ -124,7 +135,7 @@ const useInventoryBadges = () =>
         setNeedsUpdate(false);
     }, [ isVisible, needsUpdate ]);
 
-    return { badges, activeBadges, selectedBadge, isWearingBadge, canWearBadges, toggleBadge, selectBadge, setIsVisible };
+    return { badgeCodes, activeBadgeCodes, selectedBadgeCode, isWearingBadge, canWearBadges, toggleBadge, selectBadge, getBadgeId, setIsVisible };
 }
 
 export const useSharedInventoryBadges = () =>
diff --git a/src/hooks/inventory/useSharedInventoryFurni.ts b/src/hooks/inventory/useSharedInventoryFurni.ts
index 002dbfe2..a3d5c1b1 100644
--- a/src/hooks/inventory/useSharedInventoryFurni.ts
+++ b/src/hooks/inventory/useSharedInventoryFurni.ts
@@ -116,7 +116,12 @@ const useInventoryFurni = () =>
                         const group = newValue[index];
                         const item = group.remove(existingId);
 
-                        if(!item) index++;
+                        if(!item)
+                        {
+                            index++;
+
+                            continue;
+                        }
                         
                         if(getPlacingItemId() === item.ref)
                         {
@@ -183,7 +188,12 @@ const useInventoryFurni = () =>
                     const group = newValue[index];
                     const item = group.remove(parser.itemId);
 
-                    if(!item) index++;
+                    if(!item)
+                    {
+                        index++;
+
+                        continue;
+                    }
                     
                     if(getPlacingItemId() === item.ref)
                     {
diff --git a/src/hooks/inventory/useSharedInventoryTrade.ts b/src/hooks/inventory/useSharedInventoryTrade.ts
index 1df0a108..37a7b80c 100644
--- a/src/hooks/inventory/useSharedInventoryTrade.ts
+++ b/src/hooks/inventory/useSharedInventoryTrade.ts
@@ -1,9 +1,11 @@
-import { AdvancedMap, TradingAcceptComposer, TradingAcceptEvent, TradingCloseEvent, TradingCloseParser, TradingCompletedEvent, TradingConfirmationComposer, TradingConfirmationEvent, TradingListItemEvent, TradingListItemRemoveComposer, TradingNotOpenEvent, TradingOpenEvent, TradingOpenFailedEvent, TradingOpenFailedParser, TradingOtherNotAllowedEvent, TradingUnacceptComposer, TradingYouAreNotAllowedEvent } from '@nitrots/nitro-renderer';
+import { AdvancedMap, TradingAcceptComposer, TradingAcceptEvent, TradingCancelComposer, TradingCloseComposer, TradingCloseEvent, TradingCloseParser, TradingCompletedEvent, TradingConfirmationComposer, TradingConfirmationEvent, TradingListItemEvent, TradingListItemRemoveComposer, TradingNotOpenEvent, TradingOpenComposer, TradingOpenEvent, TradingOpenFailedEvent, TradingOpenFailedParser, TradingOtherNotAllowedEvent, TradingUnacceptComposer, TradingYouAreNotAllowedEvent } from '@nitrots/nitro-renderer';
 import { useCallback, useState } from 'react';
 import { useBetween } from 'use-between';
 import { useSharedInventoryFurni } from '.';
 import { BatchUpdates, UseMessageEventHook } from '..';
 import { CloneObject, GetRoomSession, GetSessionDataManager, GroupItem, LocalizeText, NotificationUtilities, SendMessageComposer, TradeState, TradeUserData, TradingNotificationMessage, TradingNotificationType } from '../../api';
+import { InventoryTradeRequestEvent } from '../../events';
+import { UseUiEvent } from '../events';
 import { parseTradeItems } from './common';
 
 const useInventoryTrade = () =>
@@ -12,6 +14,7 @@ const useInventoryTrade = () =>
     const [ otherUser, setOtherUser ] = useState<TradeUserData>(null);
     const [ tradeState, setTradeState ] = useState(TradeState.TRADING_STATE_READY);
     const { groupItems = [], setGroupItems = null } = useSharedInventoryFurni();
+    const isTrading = (tradeState >= TradeState.TRADING_STATE_RUNNING);
 
     const progressTrade = () =>
     {
@@ -49,6 +52,35 @@ const useInventoryTrade = () =>
         SendMessageComposer(new TradingListItemRemoveComposer(item.id));
     }
 
+    const stopTrading = () =>
+    {
+        if(!isTrading) return;
+
+        switch(tradeState)
+        {
+            case TradeState.TRADING_STATE_RUNNING:
+                SendMessageComposer(new TradingCloseComposer());
+                return;
+            default:
+                SendMessageComposer(new TradingCancelComposer());
+                return;
+        }
+    }
+
+    const onInventoryTradeRequestEvent = useCallback((event: InventoryTradeRequestEvent) =>
+    {
+        switch(event.type)
+        {
+            case InventoryTradeRequestEvent.REQUEST_TRADE: {
+                const tradeEvent = (event as InventoryTradeRequestEvent);
+
+                SendMessageComposer(new TradingOpenComposer(tradeEvent.objectId));
+            }
+        }
+    }, []);
+
+    UseUiEvent(InventoryTradeRequestEvent.REQUEST_TRADE, onInventoryTradeRequestEvent);
+
     const onTradingAcceptEvent = useCallback((event: TradingAcceptEvent) =>
     {
         const parser = event.getParser();
@@ -102,6 +134,7 @@ const useInventoryTrade = () =>
         {
             setOwnUser(null);
             setOtherUser(null);
+            setTradeState(TradeState.TRADING_STATE_READY);
         });
     }, [ ownUser ]);
 
@@ -115,6 +148,7 @@ const useInventoryTrade = () =>
         {
             setOwnUser(null);
             setOtherUser(null);
+            setTradeState(TradeState.TRADING_STATE_READY);
         });
     }, []);
 
@@ -143,18 +177,18 @@ const useInventoryTrade = () =>
                 {
                     newValue.creditsCount = parser.firstUserNumCredits;
                     newValue.itemCount = parser.firstUserNumItems;
-                    newValue.items = firstUserItems;
+                    newValue.userItems = firstUserItems;
                 }
                 else
                 {
                     newValue.creditsCount = parser.secondUserNumCredits;
                     newValue.itemCount = parser.secondUserNumItems;
-                    newValue.items = secondUserItems;
+                    newValue.userItems = secondUserItems;
                 }
 
                 const tradeIds: number[] = [];
 
-                for(const groupItem of newValue.items.getValues())
+                for(const groupItem of newValue.userItems.getValues())
                 {
                     let i = 0;
 
@@ -188,13 +222,13 @@ const useInventoryTrade = () =>
                 {
                     newValue.creditsCount = parser.firstUserNumCredits;
                     newValue.itemCount = parser.firstUserNumItems;
-                    newValue.items = firstUserItems;
+                    newValue.userItems = firstUserItems;
                 }
                 else
                 {
                     newValue.creditsCount = parser.secondUserNumCredits;
                     newValue.itemCount = parser.secondUserNumItems;
-                    newValue.items = secondUserItems;
+                    newValue.userItems = secondUserItems;
                 }
 
                 return newValue;
@@ -206,8 +240,6 @@ const useInventoryTrade = () =>
     const onTradingNotOpenEvent = useCallback((event: TradingNotOpenEvent) =>
     {
         const parser = event.getParser();
-
-        console.log(parser);
     }, []);
 
     UseMessageEventHook(TradingNotOpenEvent, onTradingNotOpenEvent);
@@ -287,7 +319,7 @@ const useInventoryTrade = () =>
 
     UseMessageEventHook(TradingYouAreNotAllowedEvent, onTradingYouAreNotAllowedEvent);
 
-    return { ownUser, otherUser, tradeState, setTradeState, groupItems, progressTrade, removeItem };
+    return { ownUser, otherUser, tradeState, setTradeState, isTrading, groupItems, progressTrade, removeItem, stopTrading };
 }
 
 export const useSharedInventoryTrade = () => useBetween(useInventoryTrade);
diff --git a/src/hooks/inventory/useSharedInventoryUnseenTracker.ts b/src/hooks/inventory/useSharedInventoryUnseenTracker.ts
index 29661bb8..71613edd 100644
--- a/src/hooks/inventory/useSharedInventoryUnseenTracker.ts
+++ b/src/hooks/inventory/useSharedInventoryUnseenTracker.ts
@@ -109,8 +109,6 @@ const useInventoryUnseenTracker = () =>
     {
         const parser = event.getParser();
 
-        console.log(parser);
-
         setUnseenItems(prevValue =>
             {
                 const newValue = new Map(prevValue);