[FEATURE] Send Collectibles

__tests__/components/screens/CollectibleDetailsScreen/CollectibleDetailsScreen.test.tsx

@@ -81,26 +81,35 @@ jest.mock("hooks/useGetActiveAccount", () => ({
   }),
 }));
 
+const mockGetCollectible = jest.fn(() => ({
+  name: "Test Collectible",
+  collectionName: "Test Collection",
+  tokenId: "123",
+  image: "https://example.com/image.jpg",
+  description: "Test description",
+  traits: [
+    { name: "Color", value: "Blue" },
+    { name: "Rarity", value: "Common" },
+  ],
+  externalUrl: "https://example.com",
+}));
+
 // Mock the useCollectiblesStore hook
 jest.mock("ducks/collectibles", () => ({
   useCollectiblesStore: () => ({
     fetchCollectibles: jest.fn(),
-    getCollectible: jest.fn(() => ({
-      name: "Test Collectible",
-      collectionName: "Test Collection",
-      tokenId: "123",
-      image: "https://example.com/image.jpg",
-      description: "Test description",
-      traits: [
-        { name: "Color", value: "Blue" },
-        { name: "Rarity", value: "Common" },
-      ],
-      externalUrl: "https://example.com",
-    })),
+    getCollectible: mockGetCollectible,
     isLoading: false,
   }),
 }));
 
+const mockSaveSelectedCollectibleDetails = jest.fn();
+jest.mock("ducks/transactionSettings", () => ({
+  useTransactionSettingsStore: () => ({
+    saveSelectedCollectibleDetails: mockSaveSelectedCollectibleDetails,
+  }),
+}));
+
 // Mock the getStellarExpertUrl helper
 jest.mock("helpers/stellarExpert", () => ({
   getStellarExpertUrl: jest.fn(() => "https://testnet.stellar.expert"),
@@ -199,4 +208,81 @@ describe("CollectibleDetailsScreen", () => {
       headerTitle: "Test Collectible",
     });
   });
+
+  it("renders the Send button", () => {
+    const { getByText } = renderWithProviders(
+      <CollectibleDetailsScreen
+        route={mockRoute as any}
+        navigation={mockNavigationObject as any}
+      />,
+    );
+
+    const sendButton = getByText("tokenDetailsScreen.send");
+    expect(sendButton).toBeTruthy();
+  });
+
+  it("navigates to send flow when Send button is pressed", () => {
+    mockNavigationObject.navigate.mockClear();
+    mockSaveSelectedCollectibleDetails.mockClear();
+
+    const collectibleData = mockGetCollectible();
+
+    const { getByText } = renderWithProviders(
+      <CollectibleDetailsScreen
+        route={mockRoute as any}
+        navigation={mockNavigationObject as any}
+      />,
+    );
+
+    const sendButton = getByText("tokenDetailsScreen.send");
+    fireEvent.press(sendButton);
+
+    expect(mockSaveSelectedCollectibleDetails).toHaveBeenCalledWith(
+      collectibleData,
+    );
+
+    expect(mockNavigationObject.navigate).toHaveBeenCalledWith(
+      "SendPaymentStack",
+      {
+        screen: "SendSearchContactsScreen",
+      },
+    );
+  });
+
+  it("renders View and Send buttons in a row when externalUrl exists", () => {
+    const { getByText } = renderWithProviders(
+      <CollectibleDetailsScreen
+        route={mockRoute as any}
+        navigation={mockNavigationObject as any}
+      />,
+    );
+
+    expect(getByText("collectibleDetails.view")).toBeTruthy();
+    expect(getByText("tokenDetailsScreen.send")).toBeTruthy();
+  });
+
+  it("renders only Send button when externalUrl is not present", () => {
+    mockGetCollectible.mockReturnValueOnce({
+      name: "Test Collectible",
+      collectionName: "Test Collection",
+      tokenId: "123",
+      image: "https://example.com/image.jpg",
+      description: "Test description",
+      traits: [
+        { name: "Color", value: "Blue" },
+        { name: "Rarity", value: "Common" },
+      ],
+      externalUrl: "",
+    });
+
+    const { getByText, queryByText } = renderWithProviders(
+      <CollectibleDetailsScreen
+        route={mockRoute as any}
+        navigation={mockNavigationObject as any}
+      />,
+    );
+
+    expect(getByText("tokenDetailsScreen.send")).toBeTruthy();
+    expect(queryByText("collectibleDetails.view")).toBeNull();
+  });
 });

__tests__/ducks/transactionBuilder.test.ts

@@ -302,4 +302,153 @@ describe("transactionBuilder Duck", () => {
     expect(state.transactionHash).toBeNull();
     expect(state.error).toBeNull();
   });
+
+  describe("buildSendCollectibleTransaction", () => {
+    const mockCollectionAddress =
+      "CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC";
+    const mockTokenId = 12345;
+
+    beforeEach(() => {
+      (
+        transactionService.buildSendCollectibleTransaction as jest.Mock
+      ).mockResolvedValue({
+        xdr: mockBuiltXDR,
+        tx: { toXDR: () => mockBuiltXDR, sequence: "1" },
+      });
+      (
+        transactionService.simulateCollectibleTransfer as jest.Mock
+      ).mockResolvedValue(mockPreparedXDR);
+    });
+
+    it("should build and simulate a collectible transaction successfully", async () => {
+      await act(async () => {
+        await store.getState().buildSendCollectibleTransaction({
+          collectionAddress: mockCollectionAddress,
+          destinationAccount: mockRecipientAddress,
+          tokenId: mockTokenId,
+          transactionFee: "0.001",
+          transactionTimeout: 300,
+          network: mockNetwork,
+          senderAddress: mockPublicKey,
+        });
+      });
+
+      const state = store.getState();
+      expect(state.isBuilding).toBe(false);
+      expect(state.transactionXDR).toBe(mockPreparedXDR);
+      expect(state.signedTransactionXDR).toBeNull();
+      expect(state.transactionHash).toBeNull();
+      expect(state.error).toBeNull();
+      expect(
+        transactionService.buildSendCollectibleTransaction,
+      ).toHaveBeenCalledWith(
+        expect.objectContaining({
+          collectionAddress: mockCollectionAddress,
+          recipientAddress: mockRecipientAddress,
+          tokenId: mockTokenId,
+          transactionFee: "0.001",
+          transactionTimeout: 300,
+          network: mockNetwork,
+          senderAddress: mockPublicKey,
+        }),
+      );
+      expect(transactionService.simulateCollectibleTransfer).toHaveBeenCalled();
+    });
+
+    it("should build collectible transaction with memo", async () => {
+      const memo = "Sending collectible";
+
+      await act(async () => {
+        await store.getState().buildSendCollectibleTransaction({
+          collectionAddress: mockCollectionAddress,
+          destinationAccount: mockRecipientAddress,
+          tokenId: mockTokenId,
+          transactionFee: "0.001",
+          transactionTimeout: 300,
+          transactionMemo: memo,
+          network: mockNetwork,
+          senderAddress: mockPublicKey,
+        });
+      });
+
+      expect(
+        transactionService.buildSendCollectibleTransaction,
+      ).toHaveBeenCalledWith(
+        expect.objectContaining({
+          transactionMemo: memo,
+        }),
+      );
+    });
+
+    it("should handle errors during buildSendCollectibleTransaction", async () => {
+      const buildError = new Error("Failed to build collectible transaction");
+      (
+        transactionService.buildSendCollectibleTransaction as jest.Mock
+      ).mockRejectedValue(buildError);
+
+      await act(async () => {
+        await store.getState().buildSendCollectibleTransaction({
+          collectionAddress: mockCollectionAddress,
+          destinationAccount: mockRecipientAddress,
+          tokenId: mockTokenId,
+          transactionFee: "0.001",
+          transactionTimeout: 300,
+          network: mockNetwork,
+          senderAddress: mockPublicKey,
+        });
+      });
+
+      const state = store.getState();
+      expect(state.isBuilding).toBe(false);
+      expect(state.transactionXDR).toBeNull();
+      expect(state.error).toBe(buildError.message);
+    });
+
+    it("should handle errors during simulateCollectibleTransfer", async () => {
+      const simulateError = new Error(
+        "Failed to simulate collectible transfer",
+      );
+      (
+        transactionService.simulateCollectibleTransfer as jest.Mock
+      ).mockRejectedValue(simulateError);
+
+      await act(async () => {
+        await store.getState().buildSendCollectibleTransaction({
+          collectionAddress: mockCollectionAddress,
+          destinationAccount: mockRecipientAddress,
+          tokenId: mockTokenId,
+          transactionFee: "0.001",
+          transactionTimeout: 300,
+          network: mockNetwork,
+          senderAddress: mockPublicKey,
+        });
+      });
+
+      const state = store.getState();
+      expect(state.isBuilding).toBe(false);
+      expect(state.transactionXDR).toBeNull();
+      expect(state.error).toBe(simulateError.message);
+    });
+
+    it("should return the prepared XDR from simulation", async () => {
+      let result: string | null = null;
+      await act(async () => {
+        result = await store.getState().buildSendCollectibleTransaction({
+          collectionAddress: mockCollectionAddress,
+          destinationAccount: mockRecipientAddress,
+          tokenId: mockTokenId,
+          transactionFee: "0.001",
+          transactionTimeout: 300,
+          network: mockNetwork,
+          senderAddress: mockPublicKey,
+        });
+      });
+
+      expect(result).toBe(mockPreparedXDR);
+      expect(
+        transactionService.buildSendCollectibleTransaction,
+      ).toHaveBeenCalled();
+      expect(transactionService.simulateCollectibleTransfer).toHaveBeenCalled();
+    });
+  });
 });

__tests__/ducks/transactionSettings.test.ts

@@ -99,4 +99,99 @@ describe("transactionSettings Duck", () => {
     expect(store.getState().recipientAddress).toBe("");
     expect(store.getState().selectedTokenId).toBe("");
   });
+
+  describe("selectedCollectibleDetails", () => {
+    it("should have correct initial collectible details state", () => {
+      const initialState = store.getState();
+      expect(initialState.selectedCollectibleDetails).toEqual({
+        collectionAddress: "",
+        tokenId: "",
+      });
+    });
+
+    it("should save collectible details", () => {
+      const collectibleDetails = {
+        collectionAddress:
+          "CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC",
+        tokenId: "12345",
+      };
+
+      act(() => {
+        store.getState().saveSelectedCollectibleDetails(collectibleDetails);
+      });
+
+      expect(store.getState().selectedCollectibleDetails).toEqual(
+        collectibleDetails,
+      );
+    });
+
+    it("should update collectible details when changed", () => {
+      const firstCollectible = {
+        collectionAddress:
+          "CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC",
+        tokenId: "100",
+      };
+      const secondCollectible = {
+        collectionAddress:
+          "CBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBBB",
+        tokenId: "999",
+      };
+
+      act(() => {
+        store.getState().saveSelectedCollectibleDetails(firstCollectible);
+      });
+      expect(store.getState().selectedCollectibleDetails).toEqual(
+        firstCollectible,
+      );
+
+      act(() => {
+        store.getState().saveSelectedCollectibleDetails(secondCollectible);
+      });
+      expect(store.getState().selectedCollectibleDetails).toEqual(
+        secondCollectible,
+      );
+    });
+
+    it("should reset collectible details when resetSettings is called", () => {
+      const collectibleDetails = {
+        collectionAddress:
+          "CDLZFC3SYJYDZT7K67VZ75HPJVIEUVNIXF47ZG2FB2RMQQVU2HHGCYSC",
+        tokenId: "12345",
+      };
+
+      act(() => {
+        store.getState().saveSelectedCollectibleDetails(collectibleDetails);
+      });
+
+      expect(store.getState().selectedCollectibleDetails).toEqual(
+        collectibleDetails,
+      );
+
+      act(() => {
+        store.getState().resetSettings();
+      });
+
+      expect(store.getState().selectedCollectibleDetails).toEqual({
+        collectionAddress: "",
+        tokenId: "",
+      });
+    });
+
+    it("should handle empty string values for collectible details", () => {
+      const emptyCollectibleDetails = {
+        collectionAddress: "",
+        tokenId: "",
+      };
+
+      act(() => {
+        store
+          .getState()
+          .saveSelectedCollectibleDetails(emptyCollectibleDetails);
+      });
+
+      expect(store.getState().selectedCollectibleDetails).toEqual(
+        emptyCollectibleDetails,
+      );
+    });
+  });
 });

__tests__/helpers/collectibles.test.ts

@@ -613,11 +613,8 @@ describe("collectibles helpers", () => {
     });
 
     it("throws error when transformation fails", async () => {
-      const invalidCollections = null as any;
-
-      await expect(
-        transformBackendCollections(invalidCollections),
-      ).rejects.toThrow();
+      // @ts-expect-error Testing invalid input type
+      await expect(transformBackendCollections(null)).rejects.toThrow();
 
       expect(logger.error).toHaveBeenCalledWith(
         "transformBackendCollections",