diff --git a/src/buttonEvents/Effects/Buy.ts b/src/buttonEvents/Effects/Buy.ts
index 473eb08..49cc75f 100644
--- a/src/buttonEvents/Effects/Buy.ts
+++ b/src/buttonEvents/Effects/Buy.ts
@@ -80,5 +80,41 @@ export default class Buy {
     }
 
     private static async Cancel(interaction: ButtonInteraction) {
+        const id = interaction.customId.split(" ")[3];
+        const quantity = interaction.customId.split(" ")[4];
+
+        if (!id || !quantity) {
+            AppLogger.LogError("Buy Cancel", "Not enough parameters");
+            return;
+        }
+        
+        const effectDetail = EffectDetails.get(id);
+
+        if (!effectDetail) {
+            AppLogger.LogError("Buy Cancel", "Effect detail not found!");
+            return;
+        }
+
+        const quantityNumber = Number(quantity);
+        
+        if (!quantityNumber || quantityNumber < 1) {
+            AppLogger.LogError("Buy Cancel", "Invalid number");
+            return;
+        }
+
+        const generatedEmbed = await EffectHelper.GenerateEffectBuyEmbed(interaction.user.id, id, quantityNumber, true);
+
+        if (typeof generatedEmbed == "string") {
+            await interaction.reply(generatedEmbed);
+            return;
+        }
+
+        generatedEmbed.embed.setColor(EmbedColours.Error);
+        generatedEmbed.embed.setFooter({ text: "Cancelled" });
+
+        await interaction.update({
+            embeds: [ generatedEmbed.embed ],
+            components: [ generatedEmbed.row ],
+        });
     }
 }
diff --git a/tests/buttonEvents/Effects/Buy.test.ts b/tests/buttonEvents/Effects/Buy.test.ts
index 6c7ae6b..2a4b902 100644
--- a/tests/buttonEvents/Effects/Buy.test.ts
+++ b/tests/buttonEvents/Effects/Buy.test.ts
@@ -5,9 +5,11 @@ import { ButtonInteraction as ButtonInteractionType } from "../../__types__/disc
 import AppLogger from "../../../src/client/appLogger";
 import EffectHelper from "../../../src/helpers/EffectHelper";
 import EmbedColours from "../../../src/constants/EmbedColours";
+import User from "../../../src/database/entities/app/User";
 
 jest.mock("../../../src/client/appLogger");
 jest.mock("../../../src/helpers/EffectHelper");
+jest.mock("../../../src/database/entities/app/User");
 
 let interaction: ButtonInteractionType;
 
@@ -81,13 +83,23 @@ describe("Execute", () => {
 });
 
 describe("Confirm", () => {
+    let user: User;
+
     beforeEach(() => {
         interaction.customId += " confirm";
+
+        user = {
+            Currency: 1000,
+            Save: jest.fn(),
+            RemoveCurrency: jest.fn(),
+        } as unknown as User;
+
+        (User.FetchOneById as jest.Mock).mockResolvedValue(user);
     });
 
     test("EXPECT success embed generated", async () => {
         // Assert
-        interaction.customId += " id 1";
+        interaction.customId += " unclaimed 1";
 
         const embed = {
             id: "embed",
@@ -114,7 +126,7 @@ describe("Confirm", () => {
         });
 
         expect(EffectHelper.GenerateEffectBuyEmbed).toHaveBeenCalledTimes(1);
-        expect(EffectHelper.GenerateEffectBuyEmbed).toHaveBeenCalledWith("userId", "id", 1, true);
+        expect(EffectHelper.GenerateEffectBuyEmbed).toHaveBeenCalledWith("userId", "unclaimed", 1, true);
 
         expect(embed.setColor).toHaveBeenCalledTimes(1);
         expect(embed.setColor).toHaveBeenCalledWith(EmbedColours.Success);
@@ -124,24 +136,21 @@ describe("Confirm", () => {
 
         expect(interaction.reply).not.toHaveBeenCalled();
         expect(AppLogger.LogError).not.toHaveBeenCalled();
+
+        expect(User.FetchOneById).toHaveBeenCalledTimes(1);
+        expect(User.FetchOneById).toHaveBeenCalledWith(User, "userId");
+
+        expect(user.RemoveCurrency).toHaveBeenCalledTimes(1);
+        expect(user.RemoveCurrency).toHaveBeenCalledWith(100);
+
+        expect(user.Save).toHaveBeenCalledTimes(1);
+        expect(user.Save).toHaveBeenCalledWith(User, user);
+
+        expect(EffectHelper.AddEffectToUserInventory).toHaveBeenCalledTimes(1);
+        expect(EffectHelper.AddEffectToUserInventory).toHaveBeenCalledWith("userId", "unclaimed", 1);
     });
 
     test("GIVEN id is not supplied, EXPECT error", async () => {
-        // Assert
-        const embed = {
-            id: "embed",
-            setColor: jest.fn(),
-            setFooter: jest.fn(),
-        };
-        const row = {
-            id: "row",
-        };
-        
-        (EffectHelper.GenerateEffectBuyEmbed as jest.Mock).mockResolvedValue({
-            embed,
-            row,
-        });
-
         // Act
         await Buy.Execute(interaction as unknown as ButtonInteraction);
 
@@ -156,21 +165,7 @@ describe("Confirm", () => {
 
     test("GIVEN quantity is not supplied, EXPECT error", async () => {
         // Assert
-        interaction.customId += " id";
-
-        const embed = {
-            id: "embed",
-            setColor: jest.fn(),
-            setFooter: jest.fn(),
-        };
-        const row = {
-            id: "row",
-        };
-        
-        (EffectHelper.GenerateEffectBuyEmbed as jest.Mock).mockResolvedValue({
-            embed,
-            row,
-        });
+        interaction.customId += " unclaimed";
 
         // Act
         await Buy.Execute(interaction as unknown as ButtonInteraction);
@@ -186,21 +181,7 @@ describe("Confirm", () => {
 
     test("GIVEN quantity is not a number, EXPECT error", async () => {
         // Assert
-        interaction.customId += " id invalid";
-
-        const embed = {
-            id: "embed",
-            setColor: jest.fn(),
-            setFooter: jest.fn(),
-        };
-        const row = {
-            id: "row",
-        };
-        
-        (EffectHelper.GenerateEffectBuyEmbed as jest.Mock).mockResolvedValue({
-            embed,
-            row,
-        });
+        interaction.customId += " unclaimed invalid";
 
         // Act
         await Buy.Execute(interaction as unknown as ButtonInteraction);
@@ -216,21 +197,7 @@ describe("Confirm", () => {
 
     test("GIVEN quantity is 0, EXPECT error", async () => {
         // Assert
-        interaction.customId += " id 0";
-
-        const embed = {
-            id: "embed",
-            setColor: jest.fn(),
-            setFooter: jest.fn(),
-        };
-        const row = {
-            id: "row",
-        };
-        
-        (EffectHelper.GenerateEffectBuyEmbed as jest.Mock).mockResolvedValue({
-            embed,
-            row,
-        });
+        interaction.customId += " unclaimed 0";
 
         // Act
         await Buy.Execute(interaction as unknown as ButtonInteraction);
@@ -244,13 +211,174 @@ describe("Confirm", () => {
         expect(interaction.update).not.toHaveBeenCalled();
     });
 
-    test.todo("GIVEN user is not found, EXPECT error");
+    test("GIVEN user is not found, EXPECT error", async () => {
+        // Assert
+        interaction.customId += " unclaimed 1";
 
-    test.todo("GIVEN user does not have enough currency, EXPECT error");
+        (User.FetchOneById as jest.Mock).mockResolvedValue(undefined);
+
+        // Act
+        await Buy.Execute(interaction as unknown as ButtonInteraction);
+
+        // Assert
+        expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
+        expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Confirm", "Unable to find user");
+
+        expect(EffectHelper.AddEffectToUserInventory).not.toHaveBeenCalled();
+
+        expect(interaction.update).not.toHaveBeenCalled();
+        expect(interaction.reply).not.toHaveBeenCalled();
+    });
+
+    test("GIVEN user does not have enough currency, EXPECT error", async () => {
+        // Assert
+        interaction.customId += " unclaimed 1";
+
+        user.Currency = 0;
+
+        // Act
+        await Buy.Execute(interaction as unknown as ButtonInteraction);
+
+        // Assert
+        expect(interaction.reply).toHaveBeenCalledTimes(1);
+        expect(interaction.reply).toHaveBeenCalledWith("You don't have enough currency to buy this! You have `0 Currency` and need `100 Currency`!");
+        
+        expect(EffectHelper.AddEffectToUserInventory).not.toHaveBeenCalled();
+
+        expect(interaction.update).not.toHaveBeenCalled();
+
+        expect(AppLogger.LogError).not.toHaveBeenCalled();
+    });
 
     test("GIVEN GenerateEffectBuyEmbed returns with a string, EXPECT error replied", async () => {
         // Assert
-        interaction.customId += " id 1";
+        interaction.customId += " unclaimed 1";
+        
+        (EffectHelper.GenerateEffectBuyEmbed as jest.Mock).mockResolvedValue("Test error");
+
+        // Act
+        await Buy.Execute(interaction as unknown as ButtonInteraction);
+
+        // Assert
+        expect(interaction.reply).toHaveBeenCalledTimes(1);
+        expect(interaction.reply).toHaveBeenCalledWith("Test error");
+
+        expect(EffectHelper.GenerateEffectBuyEmbed).toHaveBeenCalledTimes(1);
+
+        expect(interaction.update).not.toHaveBeenCalled();
+        expect(AppLogger.LogError).not.toHaveBeenCalled();
+    });
+});
+
+describe("Cancel", () => {
+    beforeEach(() => {
+        interaction.customId += " cancel";
+    });
+
+    test("EXPECT embed generated", async () => {
+        // Assert
+        interaction.customId += " unclaimed 1";
+
+        const embed = {
+            id: "embed",
+            setColor: jest.fn(),
+            setFooter: jest.fn(),
+        };
+        const row = {
+            id: "row",
+        };
+        
+        (EffectHelper.GenerateEffectBuyEmbed as jest.Mock).mockResolvedValue({
+            embed,
+            row,
+        });
+
+        // Act
+        await Buy.Execute(interaction as unknown as ButtonInteraction);
+
+        // Assert
+        expect(interaction.update).toHaveBeenCalledTimes(1);
+        expect(interaction.update).toHaveBeenCalledWith({
+            embeds: [ embed ],
+            components: [ row ],
+        });
+
+        expect(EffectHelper.GenerateEffectBuyEmbed).toHaveBeenCalledTimes(1);
+        expect(EffectHelper.GenerateEffectBuyEmbed).toHaveBeenCalledWith("userId", "unclaimed", 1, true);
+
+        expect(embed.setColor).toHaveBeenCalledTimes(1);
+        expect(embed.setColor).toHaveBeenCalledWith(EmbedColours.Error);
+
+        expect(embed.setFooter).toHaveBeenCalledTimes(1);
+        expect(embed.setFooter).toHaveBeenCalledWith({ text: "Cancelled" });
+
+        expect(interaction.reply).not.toHaveBeenCalled();
+        expect(AppLogger.LogError).not.toHaveBeenCalled();
+    });
+
+    test("GIVEN id is not supplied, EXPECT error", async () => {
+        // Act
+        await Buy.Execute(interaction as unknown as ButtonInteraction);
+
+        // Assert
+        expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
+        expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Cancel", "Not enough parameters");
+
+        expect(interaction.reply).not.toHaveBeenCalled();
+        expect(interaction.update).not.toHaveBeenCalled();
+    });
+
+    test("GIVEN quantity is not supplied, EXPECT error", async () => {
+        // Assert
+        interaction.customId += " unclaimed";
+
+        // Act
+        await Buy.Execute(interaction as unknown as ButtonInteraction);
+
+        // Assert
+        expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
+        expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Cancel", "Not enough parameters");
+
+        expect(EffectHelper.GenerateEffectBuyEmbed).not.toHaveBeenCalled();
+        expect(interaction.reply).not.toHaveBeenCalled();
+        expect(interaction.update).not.toHaveBeenCalled();
+    });
+
+    test("GIVEN quantity is not a number, EXPECT error", async () => {
+        // Assert
+        interaction.customId += " unclaimed invalid";
+
+        // Act
+        await Buy.Execute(interaction as unknown as ButtonInteraction);
+
+        // Assert
+        expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
+        expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Cancel", "Invalid number");
+
+        expect(EffectHelper.GenerateEffectBuyEmbed).not.toHaveBeenCalled();
+        expect(interaction.reply).not.toHaveBeenCalled();
+        expect(interaction.update).not.toHaveBeenCalled();
+    });
+
+    test("GIVEN quantity is 0, EXPECT error", async () => {
+        // Assert
+        interaction.customId += " unclaimed 0";
+
+        // Act
+        await Buy.Execute(interaction as unknown as ButtonInteraction);
+
+        // Assert
+        expect(AppLogger.LogError).toHaveBeenCalledTimes(1);
+        expect(AppLogger.LogError).toHaveBeenCalledWith("Buy Cancel", "Invalid number");
+
+        expect(EffectHelper.GenerateEffectBuyEmbed).not.toHaveBeenCalled();
+        expect(interaction.reply).not.toHaveBeenCalled();
+        expect(interaction.update).not.toHaveBeenCalled();
+    });
+
+    test("GIVEN GenerateEffectBuyEmbed returns with a string, EXPECT error replied", async () => {
+        // Assert
+        interaction.customId += " unclaimed 1";
         
         (EffectHelper.GenerateEffectBuyEmbed as jest.Mock).mockResolvedValue("Test error");