diff --git a/pom.xml b/pom.xml
index f3e2d041..8601b201 100644
--- a/pom.xml
+++ b/pom.xml
@@ -267,7 +267,7 @@
 		<dependency>
 			<groupId>io.sentry</groupId>
 			<artifactId>sentry</artifactId>
-			<version>1.6.3</version>
+			<version>1.6.5</version>
 			<scope>compile</scope>
 		</dependency>
 		<!--<dependency> <groupId>org.bstats</groupId> <artifactId>bstats-bukkit</artifactId> 
diff --git a/src/main/java/de/robotricker/transportpipes/TransportPipes.java b/src/main/java/de/robotricker/transportpipes/TransportPipes.java
index af59d7fa..a7206333 100644
--- a/src/main/java/de/robotricker/transportpipes/TransportPipes.java
+++ b/src/main/java/de/robotricker/transportpipes/TransportPipes.java
@@ -99,8 +99,17 @@ public class TransportPipes extends JavaPlugin {
 	@Override
 	public void onEnable() {
 		instance = this;
+		
+		Sentry.init("https://2eb0fc30f86a4871a85755ecdde11679:26f44195e9ef47f38e99051f7d15594f@sentry.io/252970?stacktrace.app.packages=de.robotricker");
+		Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
 
+			@Override
+			public void uncaughtException(Thread t, Throwable e) {
+				Sentry.capture(e);
+			}
+		});
 		initSentryOnCurrentThread();
+		
 		DuctType.PIPE.setDuctDetailsClass(PipeDetails.class);
 		DuctType.PIPE.setTickRunnable(new TickRunnable() {
 
@@ -365,40 +374,44 @@ public UpdateUtils getUpdateManager() {
 
 	@Override
 	public void onDisable() {
-		pipeThread.setRunning(false);
 		try {
-			pipeThread.join();
-		} catch (InterruptedException e) {
-			e.printStackTrace();
-		}
-		savingManager.saveDuctsSync(true);
-
-		// despawn all pipes and items
-		Map<World, Map<BlockLoc, Duct>> fullDuctMap = getFullDuctMap();
-		synchronized (fullDuctMap) {
-			for (Map<BlockLoc, Duct> ductMap : fullDuctMap.values()) {
-				for (Duct duct : ductMap.values()) {
-
-					ductManager.destroyDuct(duct);
-
-					if (duct instanceof Pipe) {
-						Pipe pipe = (Pipe) duct;
-						Collection<PipeItem> allItems = new ArrayList<>();
-						synchronized (pipe.pipeItems) {
-							allItems.addAll(pipe.pipeItems.keySet());
-						}
-						synchronized (pipe.tempPipeItems) {
-							allItems.addAll(pipe.tempPipeItems.keySet());
-						}
-						synchronized (pipe.tempPipeItemsWithSpawn) {
-							allItems.addAll(pipe.tempPipeItemsWithSpawn.keySet());
-						}
-						for (PipeItem pi : allItems) {
-							ductManager.destroyPipeItem(pi);
+			pipeThread.setRunning(false);
+			try {
+				pipeThread.join();
+			} catch (InterruptedException e) {
+				e.printStackTrace();
+			}
+			savingManager.saveDuctsSync(true);
+			// despawn all pipes and items
+			Map<World, Map<BlockLoc, Duct>> fullDuctMap = getFullDuctMap();
+			synchronized (fullDuctMap) {
+				for (Map<BlockLoc, Duct> ductMap : fullDuctMap.values()) {
+					for (Duct duct : ductMap.values()) {
+
+						ductManager.destroyDuct(duct);
+
+						if (duct instanceof Pipe) {
+							Pipe pipe = (Pipe) duct;
+							Collection<PipeItem> allItems = new ArrayList<>();
+							synchronized (pipe.pipeItems) {
+								allItems.addAll(pipe.pipeItems.keySet());
+							}
+							synchronized (pipe.tempPipeItems) {
+								allItems.addAll(pipe.tempPipeItems.keySet());
+							}
+							synchronized (pipe.tempPipeItemsWithSpawn) {
+								allItems.addAll(pipe.tempPipeItemsWithSpawn.keySet());
+							}
+							for (PipeItem pi : allItems) {
+								ductManager.destroyPipeItem(pi);
+							}
 						}
 					}
 				}
 			}
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
 		}
 
 	}
@@ -438,20 +451,8 @@ public static boolean isBlockProtectedByLWC(Block b) {
 	}
 
 	public static void initSentryOnCurrentThread() {
-
-		Sentry.init("https://2eb0fc30f86a4871a85755ecdde11679:26f44195e9ef47f38e99051f7d15594f@sentry.io/252970");
-		Sentry.getContext().setUser(new UserBuilder().setUsername("RoboTricker").build());
 		Sentry.getContext().addTag("thread", Thread.currentThread().getName());
 		Sentry.getContext().addTag("version", TransportPipes.instance.getDescription().getVersion());
-
-		Thread.setDefaultUncaughtExceptionHandler(new UncaughtExceptionHandler() {
-
-			@Override
-			public void uncaughtException(Thread t, Throwable e) {
-				Sentry.capture(e);
-			}
-		});
-
 	}
 
 }
diff --git a/src/main/java/de/robotricker/transportpipes/api/PipeAPI.java b/src/main/java/de/robotricker/transportpipes/api/PipeAPI.java
index ac8030c1..7befc4a4 100644
--- a/src/main/java/de/robotricker/transportpipes/api/PipeAPI.java
+++ b/src/main/java/de/robotricker/transportpipes/api/PipeAPI.java
@@ -23,6 +23,7 @@
 import de.robotricker.transportpipes.utils.WrappedDirection;
 import de.robotricker.transportpipes.utils.ductdetails.PipeDetails;
 import de.robotricker.transportpipes.utils.staticutils.DuctUtils;
+import io.sentry.Sentry;
 
 /**
  * 
@@ -105,7 +106,7 @@ public static int getDuctCount(World world) {
 	 */
 	public static boolean isDuct(Location blockLoc, DuctType dt) {
 		Duct duct = DuctUtils.getDuctAtLocation(blockLoc);
-		if(dt == null) {
+		if (dt == null) {
 			return duct != null;
 		}
 		return duct != null && duct.getDuctType() == dt;
@@ -173,23 +174,28 @@ public static void registerTransportPipesContainer(Location blockLoc, TransportP
 		}
 		containerMap.put(bl, tpc);
 
-		Map<BlockLoc, Duct> ductMap = TransportPipes.instance.getDuctMap(blockLoc.getWorld());
-		if (ductMap != null) {
-			for (WrappedDirection pd : WrappedDirection.values()) {
-				bl = BlockLoc.convertBlockLoc(blockLoc.clone().add(pd.getX(), pd.getY(), pd.getZ()));
-				if (ductMap.containsKey(bl)) {
-					final Duct duct = ductMap.get(bl);
-					if (duct.getDuctType() == DuctType.PIPE) {
-						TransportPipes.instance.pipeThread.runTask(new Runnable() {
-
-							@Override
-							public void run() {
-								TransportPipes.instance.ductManager.updateDuct((Pipe) duct);
-							}
-						}, 0);
+		try {
+			Map<BlockLoc, Duct> ductMap = TransportPipes.instance.getDuctMap(blockLoc.getWorld());
+			if (ductMap != null) {
+				for (WrappedDirection pd : WrappedDirection.values()) {
+					bl = BlockLoc.convertBlockLoc(blockLoc.clone().add(pd.getX(), pd.getY(), pd.getZ()));
+					if (ductMap.containsKey(bl)) {
+						final Duct duct = ductMap.get(bl);
+						if (duct.getDuctType() == DuctType.PIPE) {
+							TransportPipes.instance.pipeThread.runTask(new Runnable() {
+
+								@Override
+								public void run() {
+									TransportPipes.instance.ductManager.updateDuct((Pipe) duct);
+								}
+							}, 0);
+						}
 					}
 				}
 			}
+		} catch (Exception ex) {
+			ex.printStackTrace();
+			Sentry.capture(ex);
 		}
 
 	}
@@ -199,32 +205,37 @@ public void run() {
 	 * {@link PipeAPI#registerTransportPipesContainer(Location, TransportPipesContainer)}
 	 */
 	public static void unregisterTransportPipesContainer(Location blockLoc) {
-		BlockLoc bl = BlockLoc.convertBlockLoc(blockLoc);
-
-		Map<BlockLoc, TransportPipesContainer> containerMap = TransportPipes.instance.getContainerMap(blockLoc.getWorld());
-		if (containerMap != null) {
-			if (containerMap.containsKey(bl)) {
-				containerMap.remove(bl);
-
-				Map<BlockLoc, Duct> ductMap = TransportPipes.instance.getDuctMap(blockLoc.getWorld());
-				if (ductMap != null) {
-					for (WrappedDirection pd : WrappedDirection.values()) {
-						bl = BlockLoc.convertBlockLoc(blockLoc.clone().add(pd.getX(), pd.getY(), pd.getZ()));
-						if (ductMap.containsKey(bl)) {
-							final Duct duct = ductMap.get(bl);
-							if (duct.getDuctType() == DuctType.PIPE) {
-								TransportPipes.instance.pipeThread.runTask(new Runnable() {
-
-									@Override
-									public void run() {
-										TransportPipes.instance.ductManager.updateDuct((Pipe) duct);
-									}
-								}, 0);
+		try {
+			BlockLoc bl = BlockLoc.convertBlockLoc(blockLoc);
+
+			Map<BlockLoc, TransportPipesContainer> containerMap = TransportPipes.instance.getContainerMap(blockLoc.getWorld());
+			if (containerMap != null) {
+				if (containerMap.containsKey(bl)) {
+					containerMap.remove(bl);
+
+					Map<BlockLoc, Duct> ductMap = TransportPipes.instance.getDuctMap(blockLoc.getWorld());
+					if (ductMap != null) {
+						for (WrappedDirection pd : WrappedDirection.values()) {
+							bl = BlockLoc.convertBlockLoc(blockLoc.clone().add(pd.getX(), pd.getY(), pd.getZ()));
+							if (ductMap.containsKey(bl)) {
+								final Duct duct = ductMap.get(bl);
+								if (duct.getDuctType() == DuctType.PIPE) {
+									TransportPipes.instance.pipeThread.runTask(new Runnable() {
+
+										@Override
+										public void run() {
+											TransportPipes.instance.ductManager.updateDuct((Pipe) duct);
+										}
+									}, 0);
+								}
 							}
 						}
 					}
 				}
 			}
+		} catch (Exception e) {
+			e.printStackTrace();
+			Sentry.capture(e);
 		}
 
 	}
diff --git a/src/main/java/de/robotricker/transportpipes/container/BlockContainer.java b/src/main/java/de/robotricker/transportpipes/container/BlockContainer.java
index 1b65238f..e427cc2b 100644
--- a/src/main/java/de/robotricker/transportpipes/container/BlockContainer.java
+++ b/src/main/java/de/robotricker/transportpipes/container/BlockContainer.java
@@ -5,6 +5,7 @@
 import org.bukkit.inventory.ItemStack;
 
 import de.robotricker.transportpipes.api.TransportPipesContainer;
+import io.sentry.Sentry;
 
 public abstract class BlockContainer implements TransportPipesContainer {
 
@@ -31,50 +32,66 @@ public BlockContainer(Block block) {
 	 * if the item couldn't be inserted, the result item is equal to {@link before}.
 	 */
 	protected ItemStack putItemInSlot(ItemStack toPut, ItemStack before) {
-		if (toPut == null) {
-			return before;
-		}
-		if (before == null) {
-			ItemStack returnCopy = toPut.clone();
-			toPut.setAmount(0);
-			return returnCopy;
-		}
-		ItemStack beforeItemStack = before.clone();
-		if (beforeItemStack.isSimilar(toPut)) {
-			int beforeAmount = beforeItemStack.getAmount();
-			beforeItemStack.setAmount(Math.min(before.getMaxStackSize(), beforeAmount + toPut.getAmount()));
-			toPut.setAmount(Math.max(0, toPut.getAmount() - (before.getMaxStackSize() - beforeAmount)));
+		try {
+			if (toPut == null) {
+				return before;
+			}
+			if (before == null) {
+				ItemStack returnCopy = toPut.clone();
+				toPut.setAmount(0);
+				return returnCopy;
+			}
+			ItemStack beforeItemStack = before.clone();
+			if (beforeItemStack.isSimilar(toPut)) {
+				int beforeAmount = beforeItemStack.getAmount();
+				beforeItemStack.setAmount(Math.min(before.getMaxStackSize(), beforeAmount + toPut.getAmount()));
+				toPut.setAmount(Math.max(0, toPut.getAmount() - (before.getMaxStackSize() - beforeAmount)));
+			}
+			return beforeItemStack;
+		} catch (Exception e) {
+			e.printStackTrace();
+			Sentry.capture(e);
 		}
-		return beforeItemStack;
+		return null;
 	}
 
 	protected int howManyItemsFit(ItemStack toPut, ItemStack before) {
-		if (toPut == null) {
-			return 0;
-		}
-		if (before == null) {
-			return toPut.getMaxStackSize();
-		}
-		if (before.isSimilar(toPut)) {
-			if (before.getAmount() < before.getMaxStackSize()) {
-				return before.getMaxStackSize() - before.getAmount();
+		try {
+			if (toPut == null) {
+				return 0;
+			}
+			if (before == null) {
+				return toPut.getMaxStackSize();
+			}
+			if (before.isSimilar(toPut)) {
+				if (before.getAmount() < before.getMaxStackSize()) {
+					return before.getMaxStackSize() - before.getAmount();
+				} else {
+					return 0;
+				}
 			} else {
 				return 0;
 			}
-		} else {
-			return 0;
+		} catch (Exception e) {
+			e.printStackTrace();
+			Sentry.capture(e);
 		}
+		return 0;
 	}
 
 	protected boolean isInvLocked(InventoryHolder ih) {
-		// check vanilla lock
-		if (vanillaLockableExists && ih instanceof org.bukkit.block.Lockable) {
-			if (((org.bukkit.block.Lockable) ih).isLocked()) {
-				return true;
+		try {
+			// check vanilla lock
+			if (vanillaLockableExists && ih instanceof org.bukkit.block.Lockable) {
+				if (((org.bukkit.block.Lockable) ih).isLocked()) {
+					return true;
+				}
 			}
+		} catch (Exception e) {
+			e.printStackTrace();
+			Sentry.capture(e);
 		}
 		return false;
-
 	}
 
 	public abstract void updateBlock();
diff --git a/src/main/java/de/robotricker/transportpipes/container/BrewingStandContainer.java b/src/main/java/de/robotricker/transportpipes/container/BrewingStandContainer.java
index db76c57f..23a79ca7 100644
--- a/src/main/java/de/robotricker/transportpipes/container/BrewingStandContainer.java
+++ b/src/main/java/de/robotricker/transportpipes/container/BrewingStandContainer.java
@@ -12,6 +12,7 @@
 import de.robotricker.transportpipes.duct.pipe.utils.FilteringMode;
 import de.robotricker.transportpipes.pipeitems.ItemData;
 import de.robotricker.transportpipes.utils.WrappedDirection;
+import io.sentry.Sentry;
 
 public class BrewingStandContainer extends BlockContainer {
 
@@ -28,89 +29,103 @@ public BrewingStandContainer(Block block) {
 
 	@Override
 	public ItemStack extractItem(WrappedDirection extractDirection, int extractAmount, List<ItemData> filterItems, FilteringMode filteringMode) {
-		if (!cachedChunk.isLoaded()) {
-			return null;
-		}
-		if (isInvLocked(cachedBrewingStand)) {
-			return null;
-		}
-		if (extractDirection != WrappedDirection.UP && cachedBrewingStand.getBrewingTime() == 0) {
-			ItemStack taken = null;
-			if (cachedInv.getItem(0) != null && new ItemData(cachedInv.getItem(0)).checkFilter(filterItems, filteringMode)) {
-				taken = cachedInv.getItem(0);
-				cachedInv.setItem(0, null);
-			} else if (cachedInv.getItem(1) != null && new ItemData(cachedInv.getItem(1)).checkFilter(filterItems, filteringMode)) {
-				taken = cachedInv.getItem(1);
-				cachedInv.setItem(1, null);
-			} else if (cachedInv.getItem(2) != null && new ItemData(cachedInv.getItem(2)).checkFilter(filterItems, filteringMode)) {
-				taken = cachedInv.getItem(2);
-				cachedInv.setItem(2, null);
+		try {
+			if (!cachedChunk.isLoaded()) {
+				return null;
+			}
+			if (isInvLocked(cachedBrewingStand)) {
+				return null;
 			}
-			if (taken != null) {
-				return taken;
+			if (extractDirection != WrappedDirection.UP && cachedBrewingStand.getBrewingTime() == 0) {
+				ItemStack taken = null;
+				if (cachedInv.getItem(0) != null && new ItemData(cachedInv.getItem(0)).checkFilter(filterItems, filteringMode)) {
+					taken = cachedInv.getItem(0);
+					cachedInv.setItem(0, null);
+				} else if (cachedInv.getItem(1) != null && new ItemData(cachedInv.getItem(1)).checkFilter(filterItems, filteringMode)) {
+					taken = cachedInv.getItem(1);
+					cachedInv.setItem(1, null);
+				} else if (cachedInv.getItem(2) != null && new ItemData(cachedInv.getItem(2)).checkFilter(filterItems, filteringMode)) {
+					taken = cachedInv.getItem(2);
+					cachedInv.setItem(2, null);
+				}
+				if (taken != null) {
+					return taken;
+				}
 			}
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
 		}
-
 		return null;
 	}
 
 	@Override
 	public ItemStack insertItem(WrappedDirection insertDirection, ItemStack insertion) {
-		if (!cachedChunk.isLoaded()) {
-			return insertion;
-		}
-		if (isInvLocked(cachedBrewingStand)) {
-			return insertion;
-		}
-		if (insertion.getType() == Material.POTION || insertion.getType() == Material.SPLASH_POTION || insertion.getType() == Material.LINGERING_POTION) {
-			if (cachedInv.getItem(0) == null) {
-				cachedInv.setItem(0, insertion);
-				return null;
-			} else if (cachedInv.getItem(1) == null) {
-				cachedInv.setItem(1, insertion);
-				return null;
-			} else if (cachedInv.getItem(2) == null) {
-				cachedInv.setItem(2, insertion);
-				return null;
+		try {
+			if (!cachedChunk.isLoaded()) {
+				return insertion;
 			}
-		} else if (insertDirection.isSide() && insertion.getType() == Material.BLAZE_POWDER) {
-			ItemStack oldFuel = cachedInv.getFuel();
-			cachedInv.setFuel(putItemInSlot(insertion, oldFuel));
-			if (insertion == null || insertion.getAmount() == 0) {
-				insertion = null;
+			if (isInvLocked(cachedBrewingStand)) {
+				return insertion;
 			}
-		} else if (isBrewingIngredient(insertion)) {
-			ItemStack oldIngredient = cachedInv.getIngredient();
-			cachedInv.setIngredient(putItemInSlot(insertion, oldIngredient));
-			if (insertion == null || insertion.getAmount() == 0) {
-				insertion = null;
+			if (insertion.getType() == Material.POTION || insertion.getType() == Material.SPLASH_POTION || insertion.getType() == Material.LINGERING_POTION) {
+				if (cachedInv.getItem(0) == null) {
+					cachedInv.setItem(0, insertion);
+					return null;
+				} else if (cachedInv.getItem(1) == null) {
+					cachedInv.setItem(1, insertion);
+					return null;
+				} else if (cachedInv.getItem(2) == null) {
+					cachedInv.setItem(2, insertion);
+					return null;
+				}
+			} else if (insertDirection.isSide() && insertion.getType() == Material.BLAZE_POWDER) {
+				ItemStack oldFuel = cachedInv.getFuel();
+				cachedInv.setFuel(putItemInSlot(insertion, oldFuel));
+				if (insertion == null || insertion.getAmount() == 0) {
+					insertion = null;
+				}
+			} else if (isBrewingIngredient(insertion)) {
+				ItemStack oldIngredient = cachedInv.getIngredient();
+				cachedInv.setIngredient(putItemInSlot(insertion, oldIngredient));
+				if (insertion == null || insertion.getAmount() == 0) {
+					insertion = null;
+				}
 			}
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
 		}
 		return insertion;
-
 	}
 
 	@Override
 	public int howMuchSpaceForItemAsync(WrappedDirection insertDirection, ItemStack insertion) {
-		if (!cachedChunk.isLoaded()) {
-			return 0;
-		}
-		if (isInvLocked(cachedBrewingStand)) {
-			return 0;
-		}
-		if (insertion.getType() == Material.POTION || insertion.getType() == Material.SPLASH_POTION || insertion.getType() == Material.LINGERING_POTION) {
-			if (cachedInv.getItem(0) != null && cachedInv.getItem(1) != null && cachedInv.getItem(2) != null) {
+		try {
+			if (!cachedChunk.isLoaded()) {
 				return 0;
+			}
+			if (isInvLocked(cachedBrewingStand)) {
+				return 0;
+			}
+			if (insertion.getType() == Material.POTION || insertion.getType() == Material.SPLASH_POTION || insertion.getType() == Material.LINGERING_POTION) {
+				if (cachedInv.getItem(0) != null && cachedInv.getItem(1) != null && cachedInv.getItem(2) != null) {
+					return 0;
+				} else {
+					return 1;
+				}
+			} else if (insertDirection.isSide() && insertion.getType() == Material.BLAZE_POWDER) {
+				return howManyItemsFit(insertion, cachedInv.getFuel());
+			} else if (isBrewingIngredient(insertion)) {
+				return howManyItemsFit(insertion, cachedInv.getIngredient());
 			} else {
-				return 1;
+				return 0;
 			}
-		} else if (insertDirection.isSide() && insertion.getType() == Material.BLAZE_POWDER) {
-			return howManyItemsFit(insertion, cachedInv.getFuel());
-		} else if (isBrewingIngredient(insertion)) {
-			return howManyItemsFit(insertion, cachedInv.getIngredient());
-		} else {
-			return 0;
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
 		}
+		return 0;
 	}
 
 	private static boolean isBrewingIngredient(ItemStack item) {
@@ -161,9 +176,14 @@ private static boolean isBrewingIngredient(ItemStack item) {
 
 	@Override
 	public void updateBlock() {
-		this.cachedChunk = block.getChunk();
-		this.cachedBrewingStand = ((BrewingStand) block.getState());
-		this.cachedInv = cachedBrewingStand.getInventory();
+		try {
+			this.cachedChunk = block.getChunk();
+			this.cachedBrewingStand = ((BrewingStand) block.getState());
+			this.cachedInv = cachedBrewingStand.getInventory();
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
+		}
 	}
 
 }
diff --git a/src/main/java/de/robotricker/transportpipes/container/FurnaceContainer.java b/src/main/java/de/robotricker/transportpipes/container/FurnaceContainer.java
index 50084094..aa14da62 100644
--- a/src/main/java/de/robotricker/transportpipes/container/FurnaceContainer.java
+++ b/src/main/java/de/robotricker/transportpipes/container/FurnaceContainer.java
@@ -13,6 +13,7 @@
 import de.robotricker.transportpipes.protocol.ReflectionManager;
 import de.robotricker.transportpipes.utils.WrappedDirection;
 import de.robotricker.transportpipes.utils.staticutils.InventoryUtils;
+import io.sentry.Sentry;
 
 public class FurnaceContainer extends BlockContainer {
 
@@ -29,36 +30,49 @@ public FurnaceContainer(Block block) {
 
 	@Override
 	public ItemStack extractItem(WrappedDirection extractDirection, int extractAmount, List<ItemData> filterItems, FilteringMode filteringMode) {
-		if (!cachedChunk.isLoaded()) {
-			return null;
-		}
-		if (isInvLocked(cachedFurnace)) {
-			return null;
-		}
-		if (cachedInv.getResult() != null && new ItemData(cachedInv.getResult()).checkFilter(filterItems, filteringMode)) {
-			ItemStack taken = InventoryUtils.createOneAmountItemStack(cachedInv.getResult());
-			cachedInv.setResult(InventoryUtils.changeAmount(cachedInv.getResult(), -extractAmount));
-			ItemStack clonedTaken = taken.clone();
-			clonedTaken.setAmount(Math.min(taken.getAmount(), extractAmount));
-			return clonedTaken;
+		try {
+			if (!cachedChunk.isLoaded()) {
+				return null;
+			}
+			if (isInvLocked(cachedFurnace)) {
+				return null;
+			}
+			if (cachedInv.getResult() != null && new ItemData(cachedInv.getResult()).checkFilter(filterItems, filteringMode)) {
+				ItemStack taken = InventoryUtils.createOneAmountItemStack(cachedInv.getResult());
+				cachedInv.setResult(InventoryUtils.changeAmount(cachedInv.getResult(), -extractAmount));
+				ItemStack clonedTaken = taken.clone();
+				clonedTaken.setAmount(Math.min(taken.getAmount(), extractAmount));
+				return clonedTaken;
+			}
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
 		}
 		return null;
 	}
 
 	@Override
 	public ItemStack insertItem(WrappedDirection insertDirection, ItemStack insertion) {
-		if (!cachedChunk.isLoaded()) {
-			return insertion;
-		}
-		if (isInvLocked(cachedFurnace)) {
-			return insertion;
-		}
-		if (ReflectionManager.isFurnaceBurnableItem(insertion)) {
-			if (insertDirection.isSide() || insertDirection == WrappedDirection.UP) {
-				ItemStack oldSmelting = cachedInv.getSmelting();
-				cachedInv.setSmelting(putItemInSlot(insertion, oldSmelting));
-				if (insertion == null || insertion.getAmount() == 0) {
-					insertion = null;
+		try {
+			if (!cachedChunk.isLoaded()) {
+				return insertion;
+			}
+			if (isInvLocked(cachedFurnace)) {
+				return insertion;
+			}
+			if (ReflectionManager.isFurnaceBurnableItem(insertion)) {
+				if (insertDirection.isSide() || insertDirection == WrappedDirection.UP) {
+					ItemStack oldSmelting = cachedInv.getSmelting();
+					cachedInv.setSmelting(putItemInSlot(insertion, oldSmelting));
+					if (insertion == null || insertion.getAmount() == 0) {
+						insertion = null;
+					}
+				} else if (ReflectionManager.isFurnaceFuelItem(insertion)) {
+					ItemStack oldFuel = cachedInv.getFuel();
+					cachedInv.setFuel(putItemInSlot(insertion, oldFuel));
+					if (insertion == null || insertion.getAmount() == 0) {
+						insertion = null;
+					}
 				}
 			} else if (ReflectionManager.isFurnaceFuelItem(insertion)) {
 				ItemStack oldFuel = cachedInv.getFuel();
@@ -67,44 +81,52 @@ public ItemStack insertItem(WrappedDirection insertDirection, ItemStack insertio
 					insertion = null;
 				}
 			}
-		} else if (ReflectionManager.isFurnaceFuelItem(insertion)) {
-			ItemStack oldFuel = cachedInv.getFuel();
-			cachedInv.setFuel(putItemInSlot(insertion, oldFuel));
-			if (insertion == null || insertion.getAmount() == 0) {
-				insertion = null;
-			}
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
 		}
 		return insertion;
 	}
 
 	@Override
 	public int howMuchSpaceForItemAsync(WrappedDirection insertDirection, ItemStack insertion) {
-		if (!cachedChunk.isLoaded()) {
-			return 0;
-		}
-		if (isInvLocked(cachedFurnace)) {
-			return 0;
-		}
-		if (ReflectionManager.isFurnaceBurnableItem(insertion)) {
-			if (insertDirection.isSide() || insertDirection == WrappedDirection.UP) {
-				return howManyItemsFit(insertion, cachedInv.getSmelting());
+		try {
+			if (!cachedChunk.isLoaded()) {
+				return 0;
+			}
+			if (isInvLocked(cachedFurnace)) {
+				return 0;
+			}
+			if (ReflectionManager.isFurnaceBurnableItem(insertion)) {
+				if (insertDirection.isSide() || insertDirection == WrappedDirection.UP) {
+					return howManyItemsFit(insertion, cachedInv.getSmelting());
+				} else if (ReflectionManager.isFurnaceFuelItem(insertion)) {
+					return howManyItemsFit(insertion, cachedInv.getFuel());
+				} else {
+					return 0;
+				}
 			} else if (ReflectionManager.isFurnaceFuelItem(insertion)) {
 				return howManyItemsFit(insertion, cachedInv.getFuel());
 			} else {
 				return 0;
 			}
-		} else if (ReflectionManager.isFurnaceFuelItem(insertion)) {
-			return howManyItemsFit(insertion, cachedInv.getFuel());
-		} else {
-			return 0;
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
 		}
+		return 0;
 	}
 
 	@Override
 	public void updateBlock() {
-		this.cachedChunk = block.getChunk();
-		this.cachedFurnace = ((Furnace) block.getState());
-		this.cachedInv = cachedFurnace.getInventory();
+		try {
+			this.cachedChunk = block.getChunk();
+			this.cachedFurnace = ((Furnace) block.getState());
+			this.cachedInv = cachedFurnace.getInventory();
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
+		}
 	}
 
 }
diff --git a/src/main/java/de/robotricker/transportpipes/container/SimpleInventoryContainer.java b/src/main/java/de/robotricker/transportpipes/container/SimpleInventoryContainer.java
index 3e73909a..21c07b5d 100644
--- a/src/main/java/de/robotricker/transportpipes/container/SimpleInventoryContainer.java
+++ b/src/main/java/de/robotricker/transportpipes/container/SimpleInventoryContainer.java
@@ -23,6 +23,7 @@
 import de.robotricker.transportpipes.utils.BlockLoc;
 import de.robotricker.transportpipes.utils.WrappedDirection;
 import de.robotricker.transportpipes.utils.staticutils.InventoryUtils;
+import io.sentry.Sentry;
 
 public class SimpleInventoryContainer extends BlockContainer {
 
@@ -41,107 +42,135 @@ public SimpleInventoryContainer(Block block) {
 	@Override
 	public ItemStack extractItem(WrappedDirection extractDirection, int extractAmount, List<ItemData> filterItems,
 			FilteringMode filteringMode) {
-		if (!cachedChunk.isLoaded()) {
-			return null;
-		}
-		if (isInvLocked(cachedInvHolder)) {
-			return null;
-		}
-		ItemStack takenIs = null;
-		for (int i = 0; i < cachedInv.getSize(); i++) {
-			if (cachedInv.getItem(i) != null) {
-				int amountBefore = takenIs != null ? takenIs.getAmount() : 0;
-				if (takenIs == null) {
-					if (new ItemData(cachedInv.getItem(i)).checkFilter(filterItems, filteringMode)) {
-						takenIs = cachedInv.getItem(i).clone();
-						takenIs.setAmount(Math.min(extractAmount, takenIs.getAmount()));
-					} else {
-						continue;
+		ItemStack takenIs;
+		try {
+			if (!cachedChunk.isLoaded()) {
+				return null;
+			}
+			if (isInvLocked(cachedInvHolder)) {
+				return null;
+			}
+			takenIs = null;
+			for (int i = 0; i < cachedInv.getSize(); i++) {
+				if (cachedInv.getItem(i) != null) {
+					int amountBefore = takenIs != null ? takenIs.getAmount() : 0;
+					if (takenIs == null) {
+						if (new ItemData(cachedInv.getItem(i)).checkFilter(filterItems, filteringMode)) {
+							takenIs = cachedInv.getItem(i).clone();
+							takenIs.setAmount(Math.min(extractAmount, takenIs.getAmount()));
+						} else {
+							continue;
+						}
+					} else if (takenIs.isSimilar(cachedInv.getItem(i))) {
+						takenIs.setAmount(Math.min(extractAmount, amountBefore + cachedInv.getItem(i).getAmount()));
 					}
-				} else if (takenIs.isSimilar(cachedInv.getItem(i))) {
-					takenIs.setAmount(Math.min(extractAmount, amountBefore + cachedInv.getItem(i).getAmount()));
+					ItemStack invItem = cachedInv.getItem(i);
+					cachedInv.setItem(i, InventoryUtils.changeAmount(invItem, -(takenIs.getAmount() - amountBefore)));
 				}
-				ItemStack invItem = cachedInv.getItem(i);
-				cachedInv.setItem(i, InventoryUtils.changeAmount(invItem, -(takenIs.getAmount() - amountBefore)));
 			}
+			if (takenIs != null) {
+				block.getState().update();
+			}
+			return takenIs;
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
 		}
-		if (takenIs != null) {
-			block.getState().update();
-		}
-		return takenIs;
+		return null;
 	}
 
 	@Override
 	public ItemStack insertItem(WrappedDirection insertDirection, ItemStack insertion) {
-		if (!cachedChunk.isLoaded()) {
-			return insertion;
-		}
-		if (isInvLocked(cachedInvHolder)) {
-			return insertion;
-		}
-		Collection<ItemStack> overflow = cachedInv.addItem(insertion).values();
-		block.getState().update();
-		if (overflow.isEmpty()) {
-			return null;
-		} else {
-			return overflow.toArray(new ItemStack[0])[0];
+		try {
+			if (!cachedChunk.isLoaded()) {
+				return insertion;
+			}
+			if (isInvLocked(cachedInvHolder)) {
+				return insertion;
+			}
+			Collection<ItemStack> overflow = cachedInv.addItem(insertion).values();
+			block.getState().update();
+			if (overflow.isEmpty()) {
+				return null;
+			} else {
+				return overflow.toArray(new ItemStack[0])[0];
+			}
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
 		}
+		return insertion;
 	}
 
 	@Override
 	public int howMuchSpaceForItemAsync(WrappedDirection insertDirection, ItemStack insertion) {
-		if (!cachedChunk.isLoaded()) {
-			return 0;
-		}
-		if (isInvLocked(cachedInvHolder)) {
-			return 0;
-		}
-		int freeSpace = 0;
-		for (int i = 0; i < cachedInv.getSize(); i++) {
-			ItemStack is = cachedInv.getItem(i);
-			if (is == null || is.getType() == Material.AIR) {
-				freeSpace += insertion.getMaxStackSize();
-			} else if (is.isSimilar(insertion) && is.getAmount() < is.getMaxStackSize()) {
-				freeSpace += is.getMaxStackSize() - is.getAmount();
+		try {
+			if (!cachedChunk.isLoaded()) {
+				return 0;
+			}
+			if (isInvLocked(cachedInvHolder)) {
+				return 0;
+			}
+			int freeSpace = 0;
+			for (int i = 0; i < cachedInv.getSize(); i++) {
+				ItemStack is = cachedInv.getItem(i);
+				if (is == null || is.getType() == Material.AIR) {
+					freeSpace += insertion.getMaxStackSize();
+				} else if (is.isSimilar(insertion) && is.getAmount() < is.getMaxStackSize()) {
+					freeSpace += is.getMaxStackSize() - is.getAmount();
+				}
 			}
+			return freeSpace;
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
 		}
-		return freeSpace;
+		return 0;
 	}
 
 	@Override
 	public void updateBlock() {
-		this.cachedChunk = block.getChunk();
-		this.cachedInvHolder = ((InventoryHolder) block.getState());
-		this.cachedInv = cachedInvHolder.getInventory();
-		updateOtherDoubleChestBlocks();
+		try {
+			this.cachedChunk = block.getChunk();
+			this.cachedInvHolder = ((InventoryHolder) block.getState());
+			this.cachedInv = cachedInvHolder.getInventory();
+			updateOtherDoubleChestBlocks();
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
+		}
 	}
 
 	private void updateOtherDoubleChestBlocks() {
-		if (cachedInv.getHolder() instanceof DoubleChest) {
-			Material chestMaterial = block.getType();
-			Location otherChestLoc = null;
-			for (WrappedDirection pd : WrappedDirection.values()) {
-				if (pd.isSide()) {
-					if (block.getRelative(pd.getX(), pd.getY(), pd.getZ()).getType() == chestMaterial) {
-						otherChestLoc = block.getRelative(pd.getX(), pd.getY(), pd.getZ()).getLocation();
+		try {
+			if (cachedInv.getHolder() instanceof DoubleChest) {
+				Material chestMaterial = block.getType();
+				Location otherChestLoc = null;
+				for (WrappedDirection pd : WrappedDirection.values()) {
+					if (pd.isSide()) {
+						if (block.getRelative(pd.getX(), pd.getY(), pd.getZ()).getType() == chestMaterial) {
+							otherChestLoc = block.getRelative(pd.getX(), pd.getY(), pd.getZ()).getLocation();
+						}
 					}
 				}
-			}
-			Map<BlockLoc, TransportPipesContainer> containerMap = TransportPipes.instance
-					.getContainerMap(block.getWorld());
+				Map<BlockLoc, TransportPipesContainer> containerMap = TransportPipes.instance.getContainerMap(block.getWorld());
 
-			if (containerMap != null) {
-				BlockLoc bl = BlockLoc.convertBlockLoc(otherChestLoc);
-				if (containerMap.containsKey(bl)) {
-					TransportPipesContainer tpc = containerMap.get(bl);
-					if (tpc instanceof SimpleInventoryContainer) {
-						SimpleInventoryContainer sic = (SimpleInventoryContainer) tpc;
-						if (!(sic.cachedInv instanceof DoubleChestInventory)) {
-							sic.updateBlock();
+				if (containerMap != null) {
+					BlockLoc bl = BlockLoc.convertBlockLoc(otherChestLoc);
+					if (containerMap.containsKey(bl)) {
+						TransportPipesContainer tpc = containerMap.get(bl);
+						if (tpc instanceof SimpleInventoryContainer) {
+							SimpleInventoryContainer sic = (SimpleInventoryContainer) tpc;
+							if (!(sic.cachedInv instanceof DoubleChestInventory)) {
+								sic.updateBlock();
+							}
 						}
 					}
 				}
 			}
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
 		}
 	}
 
diff --git a/src/main/java/de/robotricker/transportpipes/duct/pipe/ExtractionPipe.java b/src/main/java/de/robotricker/transportpipes/duct/pipe/ExtractionPipe.java
index e42eeb66..b050abeb 100644
--- a/src/main/java/de/robotricker/transportpipes/duct/pipe/ExtractionPipe.java
+++ b/src/main/java/de/robotricker/transportpipes/duct/pipe/ExtractionPipe.java
@@ -37,6 +37,7 @@
 import de.robotricker.transportpipes.utils.staticutils.DuctItemUtils;
 import de.robotricker.transportpipes.utils.staticutils.InventoryUtils;
 import de.robotricker.transportpipes.utils.staticutils.NBTUtils;
+import io.sentry.Sentry;
 
 public class ExtractionPipe extends Pipe implements ClickableDuct, InventoryDuct {
 
@@ -47,7 +48,7 @@ public class ExtractionPipe extends Pipe implements ClickableDuct, InventoryDuct
 	private ExtractAmount extractAmount;
 	private FilteringMode filteringMode;
 	private ItemData[] filteringItems;
-	
+
 	private ExtractionPipeInv inventory;
 
 	public ExtractionPipe(Location blockLoc) {
@@ -57,7 +58,7 @@ public ExtractionPipe(Location blockLoc) {
 		extractAmount = ExtractAmount.EXTRACT_1;
 		filteringMode = FilteringMode.FILTERBY_TYPE_DAMAGE_NBT;
 		filteringItems = new ItemData[GoldenPipe.ITEMS_PER_ROW];
-		
+
 		this.inventory = new ExtractionPipeInv(this);
 	}
 
@@ -146,7 +147,7 @@ public void saveToNBTTag(CompoundMap tags) {
 	@Override
 	public void loadFromNBTTag(CompoundTag tag, long datFileVersion) {
 		super.loadFromNBTTag(tag, datFileVersion);
-		
+
 		int extractDirectionId = NBTUtils.readIntTag(tag.getValue().get("ExtractDirection"), -1);
 		if (extractDirectionId == -1) {
 			setExtractDirection(null);
@@ -172,7 +173,7 @@ public void loadFromNBTTag(CompoundTag tag, long datFileVersion) {
 	public void click(Player p, WrappedDirection side) {
 		getDuctInventory(p).openOrUpdateInventory(p);
 	}
-	
+
 	@Override
 	public DuctSharedInv getDuctInventory(Player p) {
 		return inventory;
diff --git a/src/main/java/de/robotricker/transportpipes/duct/pipe/Pipe.java b/src/main/java/de/robotricker/transportpipes/duct/pipe/Pipe.java
index b534ce38..efc6b2ce 100644
--- a/src/main/java/de/robotricker/transportpipes/duct/pipe/Pipe.java
+++ b/src/main/java/de/robotricker/transportpipes/duct/pipe/Pipe.java
@@ -38,6 +38,7 @@
 import de.robotricker.transportpipes.utils.staticutils.UpdateUtils;
 import de.robotricker.transportpipes.utils.tick.PipeTickData;
 import de.robotricker.transportpipes.utils.tick.TickData;
+import io.sentry.Sentry;
 
 public abstract class Pipe extends Duct {
 
@@ -89,50 +90,52 @@ public void removePipeItem(PipeItem item) {
 	@Override
 	public void tick(TickData tickData) {
 
-		PipeTickData pipeTickData = (PipeTickData) tickData;
+		try {
+			
+			PipeTickData pipeTickData = (PipeTickData) tickData;
+			// insert items from "tempPipeItemsWithSpawn"
+			synchronized (tempPipeItemsWithSpawn) {
+				Iterator<PipeItem> itemIterator = tempPipeItemsWithSpawn.keySet().iterator();
+				while (itemIterator.hasNext()) {
+					PipeItem pipeItem = itemIterator.next();
 
-		// insert items from "tempPipeItemsWithSpawn"
-		synchronized (tempPipeItemsWithSpawn) {
-			Iterator<PipeItem> itemIterator = tempPipeItemsWithSpawn.keySet().iterator();
-			while (itemIterator.hasNext()) {
-				PipeItem pipeItem = itemIterator.next();
-
-				WrappedDirection dir = tempPipeItemsWithSpawn.get(pipeItem);
-				putPipeItem(pipeItem, dir);
-
-				TransportPipes.instance.ductManager.createPipeItem(pipeItem);
-
-				itemIterator.remove();
-			}
-		}
+					WrappedDirection dir = tempPipeItemsWithSpawn.get(pipeItem);
+					putPipeItem(pipeItem, dir);
 
-		// put the "tempPipeItems" which had been put there by the tick method in the
-		// pipe before, into the "pipeItems" where they got affected by the tick method
-		synchronized (tempPipeItems) {
-			Iterator<PipeItem> itemIterator = tempPipeItems.keySet().iterator();
-			while (itemIterator.hasNext()) {
-				PipeItem pipeItem = itemIterator.next();
+					TransportPipes.instance.ductManager.createPipeItem(pipeItem);
 
-				// only put them there if they got into "tempPipeItems" last tick
-				if (!pipeTickData.itemsTicked.contains(pipeItem)) {
-					WrappedDirection dir = tempPipeItems.get(pipeItem);
-					putPipeItem(pipeItem, dir);
 					itemIterator.remove();
 				}
 			}
+			// put the "tempPipeItems" which had been put there by the tick method in the
+			// pipe before, into the "pipeItems" where they got affected by the tick method
+			synchronized (tempPipeItems) {
+				Iterator<PipeItem> itemIterator = tempPipeItems.keySet().iterator();
+				while (itemIterator.hasNext()) {
+					PipeItem pipeItem = itemIterator.next();
+
+					// only put them there if they got into "tempPipeItems" last tick
+					if (!pipeTickData.itemsTicked.contains(pipeItem)) {
+						WrappedDirection dir = tempPipeItems.get(pipeItem);
+						putPipeItem(pipeItem, dir);
+						itemIterator.remove();
+					}
+				}
+			}
+			List<WrappedDirection> pipeConnections = getOnlyConnectableDuctConnections();
+			List<WrappedDirection> blockConnections = getOnlyBlockConnections();
+			if (pipeTickData.extractItems && this instanceof ExtractionPipe) {
+				// extract items from inventories
+				((ExtractionPipe) this).extractItems(blockConnections);
+			}
+			// handle item transport through pipe
+			transportItems(pipeConnections, blockConnections, pipeTickData.itemsTicked);
+			
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
 		}
 
-		List<WrappedDirection> pipeConnections = getOnlyConnectableDuctConnections();
-		List<WrappedDirection> blockConnections = getOnlyBlockConnections();
-
-		if (pipeTickData.extractItems && this instanceof ExtractionPipe) {
-			// extract items from inventories
-			((ExtractionPipe) this).extractItems(blockConnections);
-		}
-
-		// handle item transport through pipe
-		transportItems(pipeConnections, blockConnections, pipeTickData.itemsTicked);
-
 	}
 
 	/**
diff --git a/src/main/java/de/robotricker/transportpipes/protocol/DuctManager.java b/src/main/java/de/robotricker/transportpipes/protocol/DuctManager.java
index 4c4942c4..8075a7ce 100644
--- a/src/main/java/de/robotricker/transportpipes/protocol/DuctManager.java
+++ b/src/main/java/de/robotricker/transportpipes/protocol/DuctManager.java
@@ -56,15 +56,19 @@ public RenderSystem getPlayerRenderSystem(Player p, DuctType ductType) {
 
 	public List<Player> getAllPlayersWithRenderSystem(RenderSystem renderSystem) {
 		List<Player> players = new ArrayList<>();
-		players.addAll(Bukkit.getOnlinePlayers());
-
-		Iterator<Player> it = players.iterator();
-		while (it.hasNext()) {
-			Player p = it.next();
-			// remove all players which don't use the given renderSystem
-			if (!getPlayerRenderSystem(p, renderSystem.getDuctType()).equals(renderSystem)) {
-				it.remove();
+		try {
+			players.addAll(Bukkit.getOnlinePlayers());
+			Iterator<Player> it = players.iterator();
+			while (it.hasNext()) {
+				Player p = it.next();
+				// remove all players which don't use the given renderSystem
+				if (!getPlayerRenderSystem(p, renderSystem.getDuctType()).equals(renderSystem)) {
+					it.remove();
+				}
 			}
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
 		}
 		return players;
 	}
diff --git a/src/main/java/de/robotricker/transportpipes/utils/hitbox/HitboxListener.java b/src/main/java/de/robotricker/transportpipes/utils/hitbox/HitboxListener.java
index 60eb8011..b135f6e7 100644
--- a/src/main/java/de/robotricker/transportpipes/utils/hitbox/HitboxListener.java
+++ b/src/main/java/de/robotricker/transportpipes/utils/hitbox/HitboxListener.java
@@ -20,133 +20,140 @@
 import de.robotricker.transportpipes.utils.ductdetails.DuctDetails;
 import de.robotricker.transportpipes.utils.staticutils.DuctItemUtils;
 import de.robotricker.transportpipes.utils.staticutils.DuctUtils;
+import io.sentry.Sentry;
 
 public class HitboxListener implements Listener {
 
 	@EventHandler(priority = EventPriority.HIGH)
 	public void onInteract(PlayerInteractEvent e) {
-		Player p = e.getPlayer();
-		Block clickedBlock = e.getClickedBlock();
-		ItemStack clickedItem;
-		boolean mainHand;
+		try {
+			Player p = e.getPlayer();
+			Block clickedBlock = e.getClickedBlock();
+			ItemStack clickedItem;
+			boolean mainHand;
 
-		if (e.getHand() == EquipmentSlot.HAND) {
-			clickedItem = e.getPlayer().getEquipment().getItemInMainHand();
-			mainHand = true;
-		} else if (e.getHand() == EquipmentSlot.OFF_HAND) {
-			if (!HitboxUtils.isInteractableItem(p.getInventory().getItemInMainHand()) && DuctItemUtils.getDuctDetailsOfItem(p.getInventory().getItemInMainHand()) == null) {
-				clickedItem = e.getPlayer().getEquipment().getItemInOffHand();
-				mainHand = false;
-			} else {
-				// using mainhand -> ignore/cancel the offhand call
-				if (clickedBlock != null && HitboxUtils.isInteractableItem(p.getInventory().getItemInOffHand())) {
-					Block placeBlock = clickedBlock.getRelative(e.getBlockFace());
-					// cancel block placement if the block would be placed inside a duct or the
-					// clickedItem in the mainHand is a duct item
-					if (DuctUtils.getDuctAtLocation(placeBlock.getLocation()) != null || DuctItemUtils.getDuctDetailsOfItem(p.getInventory().getItemInMainHand()) != null) {
-						e.setCancelled(true);
+			if (e.getHand() == EquipmentSlot.HAND) {
+				clickedItem = e.getPlayer().getEquipment().getItemInMainHand();
+				mainHand = true;
+			} else if (e.getHand() == EquipmentSlot.OFF_HAND) {
+				if (!HitboxUtils.isInteractableItem(p.getInventory().getItemInMainHand()) && DuctItemUtils.getDuctDetailsOfItem(p.getInventory().getItemInMainHand()) == null) {
+					clickedItem = e.getPlayer().getEquipment().getItemInOffHand();
+					mainHand = false;
+				} else {
+					// using mainhand -> ignore/cancel the offhand call
+					if (clickedBlock != null && HitboxUtils.isInteractableItem(p.getInventory().getItemInOffHand())) {
+						Block placeBlock = clickedBlock.getRelative(e.getBlockFace());
+						// cancel block placement if the block would be placed inside a duct or the
+						// clickedItem in the mainHand is a duct item
+						if (DuctUtils.getDuctAtLocation(placeBlock.getLocation()) != null || DuctItemUtils.getDuctDetailsOfItem(p.getInventory().getItemInMainHand()) != null) {
+							e.setCancelled(true);
+						}
 					}
+					return;
 				}
+			} else {
 				return;
 			}
-		} else {
-			return;
-		}
 
-		DuctDetails ductDetails = DuctItemUtils.getDuctDetailsOfItem(clickedItem);
+			DuctDetails ductDetails = DuctItemUtils.getDuctDetailsOfItem(clickedItem);
 
-		// left click on duct (its irrelevant if you are looking on a block below the
-		// duct or not)
-		if (e.getAction() == Action.LEFT_CLICK_AIR || e.getAction() == Action.LEFT_CLICK_BLOCK) {
-			final Block ductBlock = HitboxUtils.getDuctBlockLookingTo(p, clickedBlock);
-			// ****************************** LEFT CLICKED ON DUCT
-			// *******************************************
-			if (ductBlock != null) {
-				e.setCancelled(true);
-				if (DuctUtils.canBuild(p, ductBlock, ductBlock, mainHand ? EquipmentSlot.HAND : EquipmentSlot.OFF_HAND)) {
-					DuctUtils.destroyDuct(p, DuctUtils.getDuctAtLocation(ductBlock.getLocation()), true);
-				}
-			}
-			// right click on duct or a block (its irrelevant if you are looking on a block
-			// below the duct or not)
-		} else if (e.getAction() == Action.RIGHT_CLICK_AIR || e.getAction() == Action.RIGHT_CLICK_BLOCK) {
-			Block ductBlock = HitboxUtils.getDuctBlockLookingTo(p, clickedBlock);
-
-			if (clickedItem.getType().isBlock() && clickedItem.getType() != Material.AIR) {
-				// ****************************** PLACE BLOCK ON SIDE OF DUCT
+			// left click on duct (its irrelevant if you are looking on a block below the
+			// duct or not)
+			if (e.getAction() == Action.LEFT_CLICK_AIR || e.getAction() == Action.LEFT_CLICK_BLOCK) {
+				final Block ductBlock = HitboxUtils.getDuctBlockLookingTo(p, clickedBlock);
+				// ****************************** LEFT CLICKED ON DUCT
 				// *******************************************
 				if (ductBlock != null) {
 					e.setCancelled(true);
-					Block placeBlock = HitboxUtils.getRelativeBlockOfDuct(p, ductBlock);
-					// cancel block placement if the player clicked at the duct with a wrench
-					if (HitboxUtils.placeBlock(p, placeBlock, ductBlock, clickedItem.getTypeId(), clickedItem.getData().getData(), mainHand ? EquipmentSlot.HAND : EquipmentSlot.OFF_HAND)) {
-						HitboxUtils.decreaseItemInHand(p, mainHand);
-						return;
-					}
-					// player is looking on a block but not on a duct hitbox (check if the block can
-					// be placed there)
-					// ****************************** CANCEL BLOCK PLACEMENT INSIDE DUCT
-					// *******************************************
-				} else if (clickedBlock != null) {
-					Block placeBlock = clickedBlock.getRelative(e.getBlockFace());
-					// cancel block placement if the block would be placed inside a duct
-					if (DuctUtils.getDuctAtLocation(placeBlock.getLocation()) != null) {
-						// only cancel the interaction if the player wants to place a block inside the
-						// duct (if he looks onto an interactive block he has to sneak)
-						if (!(HitboxUtils.isInteractiveBlock(clickedBlock) || p.isSneaking())) {
-							e.setCancelled(true);
-							return;
-						}
+					if (DuctUtils.canBuild(p, ductBlock, ductBlock, mainHand ? EquipmentSlot.HAND : EquipmentSlot.OFF_HAND)) {
+						DuctUtils.destroyDuct(p, DuctUtils.getDuctAtLocation(ductBlock.getLocation()), true);
 					}
 				}
-			}
-			// place duct
-			if (ductDetails != null) {
-				// clicked on duct
-				// ****************************** PLACE PIPE ON SIDE OF DUCT
-				// *******************************************
-				if (ductBlock != null) {
-					e.setCancelled(true);
-					Block placeBlock = HitboxUtils.getRelativeBlockOfDuct(p, ductBlock);
-					if (DuctUtils.canBuild(p, placeBlock, ductBlock, mainHand ? EquipmentSlot.HAND : EquipmentSlot.OFF_HAND)) {
-						if (DuctUtils.buildDuct(e.getPlayer(), placeBlock.getLocation(), ductDetails)) {
+				// right click on duct or a block (its irrelevant if you are looking on a block
+				// below the duct or not)
+			} else if (e.getAction() == Action.RIGHT_CLICK_AIR || e.getAction() == Action.RIGHT_CLICK_BLOCK) {
+				Block ductBlock = HitboxUtils.getDuctBlockLookingTo(p, clickedBlock);
+
+				if (clickedItem.getType().isBlock() && clickedItem.getType() != Material.AIR) {
+					// ****************************** PLACE BLOCK ON SIDE OF DUCT
+					// *******************************************
+					if (ductBlock != null) {
+						e.setCancelled(true);
+						Block placeBlock = HitboxUtils.getRelativeBlockOfDuct(p, ductBlock);
+						// cancel block placement if the player clicked at the duct with a wrench
+						if (HitboxUtils.placeBlock(p, placeBlock, ductBlock, clickedItem.getTypeId(), clickedItem.getData().getData(), mainHand ? EquipmentSlot.HAND : EquipmentSlot.OFF_HAND)) {
 							HitboxUtils.decreaseItemInHand(p, mainHand);
 							return;
 						}
+						// player is looking on a block but not on a duct hitbox (check if the block can
+						// be placed there)
+						// ****************************** CANCEL BLOCK PLACEMENT INSIDE DUCT
+						// *******************************************
+					} else if (clickedBlock != null) {
+						Block placeBlock = clickedBlock.getRelative(e.getBlockFace());
+						// cancel block placement if the block would be placed inside a duct
+						if (DuctUtils.getDuctAtLocation(placeBlock.getLocation()) != null) {
+							// only cancel the interaction if the player wants to place a block inside the
+							// duct (if he looks onto an interactive block he has to sneak)
+							if (!(HitboxUtils.isInteractiveBlock(clickedBlock) || p.isSneaking())) {
+								e.setCancelled(true);
+								return;
+							}
+						}
 					}
-					// clicked on block (not below duct)
-					// ****************************** PLACE DUCT ON RELATIVE OF BLOCK
+				}
+				// place duct
+				if (ductDetails != null) {
+					// clicked on duct
+					// ****************************** PLACE PIPE ON SIDE OF DUCT
 					// *******************************************
-				} else if (clickedBlock != null) {
-					e.setUseItemInHand(Result.DENY);
-					Block placeBlock = clickedBlock.getRelative(e.getBlockFace());
-					boolean canPlace = true;
-					if (HitboxUtils.isInteractiveBlock(clickedBlock)) {
-						canPlace = p.isSneaking();
-					}
-					if (canPlace) {
-						if (DuctUtils.canBuild(p, placeBlock, clickedBlock, mainHand ? EquipmentSlot.HAND : EquipmentSlot.OFF_HAND)) {
+					if (ductBlock != null) {
+						e.setCancelled(true);
+						Block placeBlock = HitboxUtils.getRelativeBlockOfDuct(p, ductBlock);
+						if (DuctUtils.canBuild(p, placeBlock, ductBlock, mainHand ? EquipmentSlot.HAND : EquipmentSlot.OFF_HAND)) {
 							if (DuctUtils.buildDuct(e.getPlayer(), placeBlock.getLocation(), ductDetails)) {
 								HitboxUtils.decreaseItemInHand(p, mainHand);
-								e.setCancelled(true);
 								return;
 							}
 						}
+						// clicked on block (not below duct)
+						// ****************************** PLACE DUCT ON RELATIVE OF BLOCK
+						// *******************************************
+					} else if (clickedBlock != null) {
+						e.setUseItemInHand(Result.DENY);
+						Block placeBlock = clickedBlock.getRelative(e.getBlockFace());
+						boolean canPlace = true;
+						if (HitboxUtils.isInteractiveBlock(clickedBlock)) {
+							canPlace = p.isSneaking();
+						}
+						if (canPlace) {
+							if (DuctUtils.canBuild(p, placeBlock, clickedBlock, mainHand ? EquipmentSlot.HAND : EquipmentSlot.OFF_HAND)) {
+								if (DuctUtils.buildDuct(e.getPlayer(), placeBlock.getLocation(), ductDetails)) {
+									HitboxUtils.decreaseItemInHand(p, mainHand);
+									e.setCancelled(true);
+									return;
+								}
+							}
+						}
 					}
 				}
-			}
 
-			if (ductBlock != null) {
-				Duct ductClickedAt = DuctUtils.getDuctAtLocation(ductBlock.getLocation());
-				if (ductClickedAt instanceof ClickableDuct) {
-					if (DuctItemUtils.getWrenchItem().isSimilar(clickedItem)) {
-						if (DuctUtils.canBuild(p, ductClickedAt.getBlockLoc().getBlock(), ductClickedAt.getBlockLoc().getBlock(), mainHand ? EquipmentSlot.HAND : EquipmentSlot.OFF_HAND)) {
-							((ClickableDuct) ductClickedAt).click(p, HitboxUtils.getFaceOfDuctLookingTo(p, ductClickedAt));
-							e.setCancelled(true);
+				if (ductBlock != null) {
+					Duct ductClickedAt = DuctUtils.getDuctAtLocation(ductBlock.getLocation());
+					if (ductClickedAt instanceof ClickableDuct) {
+						if (DuctItemUtils.getWrenchItem().isSimilar(clickedItem)) {
+							if (DuctUtils.canBuild(p, ductClickedAt.getBlockLoc().getBlock(), ductClickedAt.getBlockLoc().getBlock(), mainHand ? EquipmentSlot.HAND : EquipmentSlot.OFF_HAND)) {
+								((ClickableDuct) ductClickedAt).click(p, HitboxUtils.getFaceOfDuctLookingTo(p, ductClickedAt));
+								e.setCancelled(true);
+							}
 						}
 					}
 				}
 			}
+
+		} catch (Exception ex) {
+			ex.printStackTrace();
+			Sentry.capture(ex);
 		}
 	}
 
diff --git a/src/main/java/de/robotricker/transportpipes/utils/hitbox/occlusionculling/BlockChangeListener.java b/src/main/java/de/robotricker/transportpipes/utils/hitbox/occlusionculling/BlockChangeListener.java
index a8545e73..42c2c523 100644
--- a/src/main/java/de/robotricker/transportpipes/utils/hitbox/occlusionculling/BlockChangeListener.java
+++ b/src/main/java/de/robotricker/transportpipes/utils/hitbox/occlusionculling/BlockChangeListener.java
@@ -24,6 +24,7 @@
 import org.bukkit.event.world.ChunkUnloadEvent;
 
 import de.robotricker.transportpipes.TransportPipes;
+import io.sentry.Sentry;
 
 public class BlockChangeListener implements Listener {
 
@@ -94,10 +95,16 @@ public void run() {
 	}
 
 	public boolean isInLoadedChunk(Location loc) {
-		int chunkX = (int) Math.floor(loc.getBlockX() / 16d);
-		int chunkZ = (int) Math.floor(loc.getBlockZ() / 16d);
-		ChunkCoords cc = new ChunkCoords(loc.getWorld().getName(), chunkX, chunkZ);
-		return cachedChunkSnapshots.containsKey(cc);
+		try {
+			int chunkX = (int) Math.floor(loc.getBlockX() / 16d);
+			int chunkZ = (int) Math.floor(loc.getBlockZ() / 16d);
+			ChunkCoords cc = new ChunkCoords(loc.getWorld().getName(), chunkX, chunkZ);
+			return cachedChunkSnapshots.containsKey(cc);
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
+		}
+		return false;
 	}
 
 	public static class ChunkCoords {
diff --git a/src/main/java/de/robotricker/transportpipes/utils/hitbox/occlusionculling/OcclusionCullingUtils.java b/src/main/java/de/robotricker/transportpipes/utils/hitbox/occlusionculling/OcclusionCullingUtils.java
index 6a676e32..2d0bcf10 100644
--- a/src/main/java/de/robotricker/transportpipes/utils/hitbox/occlusionculling/OcclusionCullingUtils.java
+++ b/src/main/java/de/robotricker/transportpipes/utils/hitbox/occlusionculling/OcclusionCullingUtils.java
@@ -24,73 +24,75 @@ public static boolean isDuctVisibleForPlayer(Player p, Duct duct) {
 	public static boolean isPipeItemVisibleForPlayer(Player p, PipeItem item) {
 		return isAABBVisible(item.getBlockLoc(), blockAABB, p.getEyeLocation());
 	}
-	
-	private static boolean isAABBVisible(Location aabbBlock, AxisAlignedBB aabb, Location playerLoc) {
 
-		double width = aabb.getWidth();
-		double height = aabb.getHeight();
-		double depth = aabb.getDepth();
-
-		Location center = aabb.getAABBMiddle(aabbBlock).toLocation(aabbBlock.getWorld());
-
-		Location centerXMin = center.clone().add(-width / 2, 0, 0);
-		Location centerXMax = center.clone().add(width / 2, 0, 0);
-		Location centerYMin = center.clone().add(0, -height / 2, 0);
-		Location centerYMax = center.clone().add(0, height / 2, 0);
-		Location centerZMin = center.clone().add(0, 0, -depth / 2);
-		Location centerZMax = center.clone().add(0, 0, depth / 2);
-
-		boolean centerXMinBlocked = false;
-		Vector[] locs = gridRaytrace(playerLoc, centerXMin.subtract(playerLoc).toVector());
-		for (Vector v : locs) {
-			if (isBlockAtLocationOccluding(v.toLocation(playerLoc.getWorld()))) {
-				centerXMinBlocked = true;
-				break;
+	private static boolean isAABBVisible(Location aabbBlock, AxisAlignedBB aabb, Location playerLoc) {
+		try {
+			double width = aabb.getWidth();
+			double height = aabb.getHeight();
+			double depth = aabb.getDepth();
+			Location center = aabb.getAABBMiddle(aabbBlock).toLocation(aabbBlock.getWorld());
+			Location centerXMin = center.clone().add(-width / 2, 0, 0);
+			Location centerXMax = center.clone().add(width / 2, 0, 0);
+			Location centerYMin = center.clone().add(0, -height / 2, 0);
+			Location centerYMax = center.clone().add(0, height / 2, 0);
+			Location centerZMin = center.clone().add(0, 0, -depth / 2);
+			Location centerZMax = center.clone().add(0, 0, depth / 2);
+			boolean centerXMinBlocked = false;
+			Vector[] locs = gridRaytrace(playerLoc, centerXMin.subtract(playerLoc).toVector());
+			for (Vector v : locs) {
+				if (isBlockAtLocationOccluding(v.toLocation(playerLoc.getWorld()))) {
+					centerXMinBlocked = true;
+					break;
+				}
 			}
-		}
-		boolean centerXMaxBlocked = false;
-		locs = gridRaytrace(playerLoc, centerXMax.subtract(playerLoc).toVector());
-		for (Vector v : locs) {
-			if (isBlockAtLocationOccluding(v.toLocation(playerLoc.getWorld()))) {
-				centerXMaxBlocked = true;
-				break;
+			boolean centerXMaxBlocked = false;
+			locs = gridRaytrace(playerLoc, centerXMax.subtract(playerLoc).toVector());
+			for (Vector v : locs) {
+				if (isBlockAtLocationOccluding(v.toLocation(playerLoc.getWorld()))) {
+					centerXMaxBlocked = true;
+					break;
+				}
 			}
-		}
-		boolean centerYMinBlocked = false;
-		locs = gridRaytrace(playerLoc, centerYMin.subtract(playerLoc).toVector());
-		for (Vector v : locs) {
-			if (isBlockAtLocationOccluding(v.toLocation(playerLoc.getWorld()))) {
-				centerYMinBlocked = true;
-				break;
+			boolean centerYMinBlocked = false;
+			locs = gridRaytrace(playerLoc, centerYMin.subtract(playerLoc).toVector());
+			for (Vector v : locs) {
+				if (isBlockAtLocationOccluding(v.toLocation(playerLoc.getWorld()))) {
+					centerYMinBlocked = true;
+					break;
+				}
 			}
-		}
-		boolean centerYMaxBlocked = false;
-		locs = gridRaytrace(playerLoc, centerYMax.subtract(playerLoc).toVector());
-		for (Vector v : locs) {
-			if (isBlockAtLocationOccluding(v.toLocation(playerLoc.getWorld()))) {
-				centerYMaxBlocked = true;
-				break;
+			boolean centerYMaxBlocked = false;
+			locs = gridRaytrace(playerLoc, centerYMax.subtract(playerLoc).toVector());
+			for (Vector v : locs) {
+				if (isBlockAtLocationOccluding(v.toLocation(playerLoc.getWorld()))) {
+					centerYMaxBlocked = true;
+					break;
+				}
 			}
-		}
-		boolean centerZMinBlocked = false;
-		locs = gridRaytrace(playerLoc, centerZMin.subtract(playerLoc).toVector());
-		for (Vector v : locs) {
-			if (isBlockAtLocationOccluding(v.toLocation(playerLoc.getWorld()))) {
-				centerZMinBlocked = true;
-				break;
+			boolean centerZMinBlocked = false;
+			locs = gridRaytrace(playerLoc, centerZMin.subtract(playerLoc).toVector());
+			for (Vector v : locs) {
+				if (isBlockAtLocationOccluding(v.toLocation(playerLoc.getWorld()))) {
+					centerZMinBlocked = true;
+					break;
+				}
 			}
-		}
-		boolean centerZMaxBlocked = false;
-		locs = gridRaytrace(playerLoc, centerZMax.subtract(playerLoc).toVector());
-		for (Vector v : locs) {
-			if (isBlockAtLocationOccluding(v.toLocation(playerLoc.getWorld()))) {
-				centerZMaxBlocked = true;
-				break;
+			boolean centerZMaxBlocked = false;
+			locs = gridRaytrace(playerLoc, centerZMax.subtract(playerLoc).toVector());
+			for (Vector v : locs) {
+				if (isBlockAtLocationOccluding(v.toLocation(playerLoc.getWorld()))) {
+					centerZMaxBlocked = true;
+					break;
+				}
 			}
-		}
+			boolean visible = !centerXMinBlocked || !centerXMaxBlocked || !centerYMinBlocked || !centerYMaxBlocked || !centerZMinBlocked || !centerZMaxBlocked;
+			return visible;
 
-		boolean visible = !centerXMinBlocked || !centerXMaxBlocked || !centerYMinBlocked || !centerYMaxBlocked || !centerZMinBlocked || !centerZMaxBlocked;
-		return visible;
+		} catch (Exception exception) {
+			exception.printStackTrace();
+			Sentry.capture(exception);
+		}
+		return true;
 	}
 
 	@SuppressWarnings("deprecation")