diff --git a/tests/v1/nodInfra.test.ts b/tests/v1/nodInfra.test.ts
index 9420dfb..3553c00 100644
--- a/tests/v1/nodInfra.test.ts
+++ b/tests/v1/nodInfra.test.ts
@@ -1,14 +1,15 @@
 var request = require("supertest");
 import {
+  ENV,
   baseURL,
   createAuthTokenForNodeInfra,
-  generatorNodeApiKey,
-  validatorNodeApiKey,
-  masterNodeApiKey,
   generatorNodePublicKey,
   validatorNodePublicKey,
   masterNodePublicKey,
 } from "../constants/constants";
+import { address } from "./session.test";
+const validRpcNodeListApiUrl = `/api/v1/rpcNodes/list?address=${generatorNodePublicKey}&nodeType=generator`;
+const inValidRpcNodeListApiUrl = "/api/v1/rpcNode/list";
 const validNetworkListApiUrl = "/api/v1/networks/list";
 const inValidNetworkListApiUrl = "/api/v1/network/list";
 const validTransactionListApiUrl = "/api/v1/transactions/list";
@@ -22,9 +23,91 @@ const inValidUpdateValidatorApiUrl =
   "/api/v1/transactions/update/from/validators";
 const validUpdateMasterApiUrl = "/api/v1/transactions/update/from/master";
 const inValidUpdateMasterApiUrl = "/api/v1/transactions/update/from/masters";
+const validGetFeeDistributionApiUrl = `/api/v1/referrals/fee-distribution?walletAddress=${address}`;
+const inValidGetFeeDistributionApiUrl = "/api/referrals/fee-distributions";
 const transactionTxId =
   "0x9401a086c1eb1bc104a95ee0ff980a456033bac10f2d7cbc5139a33dd0636190";
 
+describe("API Endpoint Testing", () => {
+  it("should return fee distribution with status 200", async () => {
+    const res = await request(baseURL)
+      .get(`${validGetFeeDistributionApiUrl}`)
+      .set(
+        "Authorization",
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.fiberApiKey)}`
+      );
+    expect(res.statusCode).toEqual(200);
+    expect(res.body.body).toHaveProperty("feeDistribution");
+  });
+
+  it("should return an error with invalid token", async () => {
+    const res = await request(baseURL)
+      .get(`${validGetFeeDistributionApiUrl}`)
+      .set("Authorization", "Bearer invalid_token");
+    expect(res.statusCode).toEqual(401);
+  });
+
+  it("should handle non-existent endpoint with status 404", async () => {
+    const res = await request(baseURL)
+      .get(`${inValidGetFeeDistributionApiUrl}`)
+      .set(
+        "Authorization",
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.fiberApiKey)}`
+      );
+    expect(res.statusCode).toEqual(404);
+  });
+
+  it("should return 404 for invalid method (POST)", async () => {
+    const res = await request(baseURL)
+      .post(`${validGetFeeDistributionApiUrl}`)
+      .set(
+        "Authorization",
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.fiberApiKey)}`
+      );
+    expect(res.statusCode).toEqual(404);
+  });
+});
+
+describe("API Endpoint Testing", () => {
+  it("should return a list of rpc nodes with status 200", async () => {
+    const res = await request(baseURL)
+      .get(`${validRpcNodeListApiUrl}`)
+      .set(
+        "Authorization",
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.generatorNodeApiKey)}`
+      );
+    expect(res.statusCode).toEqual(200);
+    expect(res.body.body).toHaveProperty("data");
+  });
+
+  it("should return an error with invalid token", async () => {
+    const res = await request(baseURL)
+      .get(`${validRpcNodeListApiUrl}`)
+      .set("Authorization", "Bearer invalid_token");
+    expect(res.statusCode).toEqual(401);
+  });
+
+  it("should handle non-existent endpoint with status 404", async () => {
+    const res = await request(baseURL)
+      .get(`${inValidRpcNodeListApiUrl}`)
+      .set(
+        "Authorization",
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.generatorNodeApiKey)}`
+      );
+    expect(res.statusCode).toEqual(404);
+  });
+
+  it("should return 404 for invalid method (POST)", async () => {
+    const res = await request(baseURL)
+      .post(`${validRpcNodeListApiUrl}`)
+      .set(
+        "Authorization",
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.generatorNodeApiKey)}`
+      );
+    expect(res.statusCode).toEqual(404);
+  });
+});
+
 describe("API Endpoint Testing", () => {
   it("should return a list of networks with status 200", async () => {
     const res = await request(baseURL).get(validNetworkListApiUrl);
@@ -51,7 +134,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(generatorNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.generatorNodeApiKey)}`
       );
     expect(res.statusCode).toEqual(200);
     expect(res.body.body).toHaveProperty("transactions");
@@ -73,7 +156,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(generatorNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.generatorNodeApiKey)}`
       );
     expect(res.statusCode).toEqual(404);
   });
@@ -85,7 +168,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(generatorNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.generatorNodeApiKey)}`
       );
     expect(res.statusCode).toEqual(404);
   });
@@ -99,7 +182,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(validatorNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.validatorNodeApiKey)}`
       );
     expect(res.statusCode).toEqual(200);
     expect(res.body.body).toHaveProperty("transactions");
@@ -121,7 +204,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(validatorNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.validatorNodeApiKey)}`
       );
     expect(res.statusCode).toEqual(404);
   });
@@ -133,7 +216,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(validatorNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.validatorNodeApiKey)}`
       );
     expect(res.statusCode).toEqual(404);
   });
@@ -147,7 +230,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(masterNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.masterNodeApiKey)}`
       );
     expect(res.statusCode).toEqual(200);
     expect(res.body.body).toHaveProperty("transactions");
@@ -169,7 +252,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(masterNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.masterNodeApiKey)}`
       );
     expect(res.statusCode).toEqual(404);
   });
@@ -181,7 +264,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(masterNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.masterNodeApiKey)}`
       );
     expect(res.statusCode).toEqual(404);
   });
@@ -196,7 +279,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(generatorNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.generatorNodeApiKey)}`
       )
       .send({}); // sent empty body. Reason is already given above
     expect(res.statusCode).toEqual(200);
@@ -229,7 +312,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(generatorNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.generatorNodeApiKey)}`
       )
       .send({});
     expect(res.statusCode).toEqual(404);
@@ -242,7 +325,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(generatorNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.generatorNodeApiKey)}`
       )
       .send({});
     expect(res.statusCode).toEqual(404);
@@ -258,7 +341,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(validatorNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.validatorNodeApiKey)}`
       )
       .send({}); // sent empty body. Reason is already given above
     expect(res.statusCode).toEqual(200);
@@ -291,7 +374,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(validatorNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.validatorNodeApiKey)}`
       )
       .send({});
     expect(res.statusCode).toEqual(404);
@@ -304,7 +387,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(validatorNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.validatorNodeApiKey)}`
       )
       .send({});
     expect(res.statusCode).toEqual(404);
@@ -320,7 +403,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(masterNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.masterNodeApiKey)}`
       )
       .send({}); // sent empty body. Reason is already given above
     expect(res.statusCode).toEqual(200);
@@ -353,7 +436,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(masterNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.masterNodeApiKey)}`
       )
       .send({});
     expect(res.statusCode).toEqual(404);
@@ -366,7 +449,7 @@ describe("API Endpoint Testing", () => {
       )
       .set(
         "Authorization",
-        `Bearer ${await createAuthTokenForNodeInfra(masterNodeApiKey)}`
+        `Bearer ${await createAuthTokenForNodeInfra(ENV?.masterNodeApiKey)}`
       )
       .send({});
     expect(res.statusCode).toEqual(404);
diff --git a/tests/v1/referralFeeManagement.test.ts b/tests/v1/referralFeeManagement.test.ts
new file mode 100644
index 0000000..abe76f8
--- /dev/null
+++ b/tests/v1/referralFeeManagement.test.ts
@@ -0,0 +1,165 @@
+var request = require("supertest");
+import { baseURL } from "../constants/constants";
+import { superAdminSessionToken } from "./users.test";
+import { sessionToken } from "./session.test";
+const validCreateRFMApiUrl = "/api/v1/super-admin/referralFeeManagement/create";
+const inValidCreateRFMApiUrl = "/api/super-admin/referralFeeManagements/create";
+const validUpdateRFMApiUrl =
+  "/api/v1/super-admin/referralFeeManagement/update/";
+const inValidUpdateRFMApiUrl = "/api/super-admin/referralFeeManagement/update/";
+const validCreateReferralApiUrl =
+  "/api/v1/community-member/multiSwap/referrals/create/referral/code";
+const inValidCreateReferralApiUrl =
+  "/api/community-member/multiSwap/referral/create/referral/code";
+const validGetReferralApiUrl =
+  "/api/v1/community-member/multiSwap/referrals/referral/code";
+const inValidGetReferralApiUrl =
+  "/api/community-member/multiSwap/referral/referral/code";
+let rfmId = "";
+
+describe("API Endpoint Testing", () => {
+  it("should create referralFeeManagements successfully", async () => {
+    const res = await request(baseURL)
+      .post(validCreateRFMApiUrl)
+      .send({
+        tier: "GeneralX",
+        fee: 10,
+        discount: 50,
+        feeType: "PERCENTAGE",
+        userAddresses: [],
+      })
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(200);
+    rfmId = res.body.body.referralFeeManagement._id;
+  });
+
+  it("should return an error with missing required fields", async () => {
+    const res = await request(baseURL)
+      .post(validCreateRFMApiUrl)
+      .send({
+        tier: "",
+        fee: 10,
+        feeType: "",
+        userAddresses: [],
+      })
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(400);
+  });
+
+  it("should handle non-existent endpoint with status 404", async () => {
+    const res = await request(baseURL)
+      .post(inValidCreateRFMApiUrl)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+
+  it("should return 404 for invalid method (GET)", async () => {
+    const res = await request(baseURL)
+      .put(validCreateRFMApiUrl)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+});
+
+describe("API Endpoint Testing", () => {
+  it("should update referralFeeManagements successfully", async () => {
+    const res = await request(baseURL)
+      .put(`${validUpdateRFMApiUrl}${rfmId}`)
+      .send({
+        tier: "GeneralX",
+        fee: 20,
+        discount: 30,
+        feeType: "PERCENTAGE",
+        userAddresses: [],
+      })
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(200);
+  });
+
+  it("should return an error with missing required fields", async () => {
+    const res = await request(baseURL)
+      .put(`${validUpdateRFMApiUrl}${rfmId}`)
+      .send({
+        tier: "",
+        fee: 10,
+        feeType: "",
+        userAddresses: [],
+      })
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(400);
+  });
+
+  it("should handle non-existent endpoint with status 404", async () => {
+    const res = await request(baseURL)
+      .put(`${inValidUpdateRFMApiUrl}${rfmId}`)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+
+  it("should return 404 for invalid method (GET)", async () => {
+    const res = await request(baseURL)
+      .post(`${validUpdateRFMApiUrl}${rfmId}`)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+});
+
+describe("API Endpoint Testing", () => {
+  it("should create referral successfully", async () => {
+    const res = await request(baseURL)
+      .post(validCreateReferralApiUrl)
+      .set("Authorization", `Bearer ${sessionToken}`);
+    expect(res.statusCode).toEqual(200);
+  });
+
+  it("should handle non-existent endpoint with status 404", async () => {
+    const res = await request(baseURL)
+      .post(inValidCreateReferralApiUrl)
+      .set("Authorization", `Bearer ${sessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+
+  it("should return 404 for invalid method (PUT)", async () => {
+    const res = await request(baseURL)
+      .put(validCreateReferralApiUrl)
+      .set("Authorization", `Bearer ${sessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+});
+
+describe("API Endpoint Testing", () => {
+  it("should return a single referral data with status 200", async () => {
+    const res = await request(baseURL)
+      .get(`${validGetReferralApiUrl}`)
+      .set("Authorization", `Bearer ${sessionToken}`);
+    expect(res.statusCode).toEqual(200);
+    expect(res.body.body).toHaveProperty("referral");
+  });
+
+  it("should return an error for invalid token", async () => {
+    const res = await request(baseURL)
+      .get(`${validGetReferralApiUrl}`)
+      .set("Authorization", "invalid-api-key");
+    expect(res.statusCode).toEqual(401);
+    expect(res.body.status).toHaveProperty("message");
+  });
+
+  it("should return an error for missing token", async () => {
+    const res = await request(baseURL).get(`${validGetReferralApiUrl}`);
+    expect(res.statusCode).toEqual(401);
+  });
+
+  it("should handle non-existent endpoint with status 404", async () => {
+    const res = await request(baseURL)
+      .get(`${inValidGetReferralApiUrl}`)
+      .set("Authorization", `Bearer ${sessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+
+  it("should return 404 for invalid method (POST)", async () => {
+    const res = await request(baseURL)
+      .post(`${validGetReferralApiUrl}`)
+      .set("Authorization", `Bearer ${sessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+});
diff --git a/tests/v1/rpcNode.test.ts b/tests/v1/rpcNode.test.ts
new file mode 100644
index 0000000..36f3754
--- /dev/null
+++ b/tests/v1/rpcNode.test.ts
@@ -0,0 +1,213 @@
+var request = require("supertest");
+var crypto = require("crypto");
+import { baseURL } from "../constants/constants";
+import { superAdminSessionToken } from "./users.test";
+const validRpcNodesApiUrl = "/api/v1/super-admin/rpcNodes/list";
+const inValidRpcNodesApiUrl = "/api/super-admin/rpcNode/list";
+const validRpcNodeByIdApiUrl = "/api/v1/super-admin/rpcNodes/";
+const inValidRpcNodeByIdApiUrl = "/api/super-admin/rpcNode/";
+const validCreateRpcNodeApiUrl = "/api/v1/super-admin/rpcNodes/create";
+const inValidCreateRpcNodeApiUrl = "/api/super-admin/rpcNode/create";
+const validUpdateRpcNodeApiUrl = "/api/v1/super-admin/rpcNodes/update/";
+const inValidUpdateRpcNodeApiUrl = "/api/super-admin/rpcNode/update/";
+let rpcNodeId = "";
+let address = crypto.randomBytes(10).toString("hex");
+
+describe("API Endpoint Testing", () => {
+  it("should return a list of rpc nodes with status 200", async () => {
+    const res = await request(baseURL)
+      .get(validRpcNodesApiUrl)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(200);
+    expect(res.body.body).toHaveProperty("data");
+  });
+
+  it("should return an error for invalid token", async () => {
+    const res = await request(baseURL)
+      .get(validRpcNodesApiUrl)
+      .set("Authorization", "invalid-api-key");
+    expect(res.statusCode).toEqual(401);
+    expect(res.body.status).toHaveProperty("message");
+  });
+
+  it("should return an error for missing token", async () => {
+    const res = await request(baseURL).get(validRpcNodesApiUrl);
+    expect(res.statusCode).toEqual(401);
+  });
+
+  it("should handle non-existent endpoint with status 404", async () => {
+    const res = await request(baseURL)
+      .get(inValidRpcNodesApiUrl)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+
+  it("should return 404 for invalid method (POST)", async () => {
+    const res = await request(baseURL)
+      .post(validRpcNodesApiUrl)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+});
+
+describe("API Endpoint Testing", () => {
+  it("should create rpc node successfully", async () => {
+    const res = await request(baseURL)
+      .post(validCreateRpcNodeApiUrl)
+      .send({
+        address: address,
+        url: "https://abc.com",
+        type: "generator",
+        chainId: "22",
+      })
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(200);
+    rpcNodeId = res.body.body.rpcNode._id;
+  });
+
+  it("should return an error with missing required fields", async () => {
+    const res = await request(baseURL)
+      .post(validCreateRpcNodeApiUrl)
+      .send({
+        address: "",
+        url: "",
+        type: "",
+        chainId: "",
+      })
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(400);
+  });
+
+  it("should handle non-existent endpoint with status 404", async () => {
+    const res = await request(baseURL)
+      .post(inValidCreateRpcNodeApiUrl)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+
+  it("should return 404 for invalid method (GET)", async () => {
+    const res = await request(baseURL)
+      .put(validCreateRpcNodeApiUrl)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+});
+
+describe("API Endpoint Testing", () => {
+  it("should update rpc node successfully", async () => {
+    const res = await request(baseURL)
+      .put(`${validUpdateRpcNodeApiUrl}${rpcNodeId}`)
+      .send({
+        address: address + "x",
+        url: "https://abc.com",
+        type: "generator",
+        chainId: "22",
+      })
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(200);
+  });
+
+  it("should return an error with missing required fields", async () => {
+    const res = await request(baseURL)
+      .put(`${validUpdateRpcNodeApiUrl}${rpcNodeId}`)
+      .send({
+        address: "",
+        url: "",
+        type: "",
+        chainId: "",
+      })
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(400);
+  });
+
+  it("should handle non-existent endpoint with status 404", async () => {
+    const res = await request(baseURL)
+      .put(`${inValidUpdateRpcNodeApiUrl}${rpcNodeId}`)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+
+  it("should return 404 for invalid method (GET)", async () => {
+    const res = await request(baseURL)
+      .post(`${validUpdateRpcNodeApiUrl}${rpcNodeId}`)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+});
+
+describe("API Endpoint Testing", () => {
+  it("should return a single rpc node data with status 200", async () => {
+    const res = await request(baseURL)
+      .get(`${validRpcNodeByIdApiUrl}${rpcNodeId}`)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(200);
+    expect(res.body.body).toHaveProperty("rpcNode");
+  });
+
+  it("should return an error for invalid token", async () => {
+    const res = await request(baseURL)
+      .get(`${validRpcNodeByIdApiUrl}${rpcNodeId}`)
+      .set("Authorization", "invalid-api-key");
+    expect(res.statusCode).toEqual(401);
+    expect(res.body.status).toHaveProperty("message");
+  });
+
+  it("should return an error for missing token", async () => {
+    const res = await request(baseURL).get(
+      `${validRpcNodeByIdApiUrl}${rpcNodeId}`
+    );
+    expect(res.statusCode).toEqual(401);
+  });
+
+  it("should handle non-existent endpoint with status 404", async () => {
+    const res = await request(baseURL)
+      .get(`${inValidRpcNodeByIdApiUrl}${rpcNodeId}`)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+
+  it("should return 404 for invalid method (POST)", async () => {
+    const res = await request(baseURL)
+      .post(`${validRpcNodeByIdApiUrl}${rpcNodeId}`)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+});
+
+describe("API Endpoint Testing", () => {
+  it("should delete single rpc node with status 200", async () => {
+    const res = await request(baseURL)
+      .delete(`${validRpcNodeByIdApiUrl}${rpcNodeId}`)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(200);
+  });
+
+  it("should return an error for invalid token", async () => {
+    const res = await request(baseURL)
+      .delete(`${validRpcNodeByIdApiUrl}${rpcNodeId}`)
+      .set("Authorization", "invalid-api-key");
+    expect(res.statusCode).toEqual(401);
+    expect(res.body.status).toHaveProperty("message");
+  });
+
+  it("should return an error for missing token", async () => {
+    const res = await request(baseURL).delete(
+      `${validRpcNodeByIdApiUrl}+${rpcNodeId}`
+    );
+    expect(res.statusCode).toEqual(401);
+  });
+
+  it("should handle non-existent endpoint with status 404", async () => {
+    const res = await request(baseURL)
+      .delete(`${inValidRpcNodeByIdApiUrl}${rpcNodeId}`)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+
+  it("should return 404 for invalid method (POST)", async () => {
+    const res = await request(baseURL)
+      .post(`${validRpcNodeByIdApiUrl}${rpcNodeId}`)
+      .set("Authorization", `Bearer ${superAdminSessionToken}`);
+    expect(res.statusCode).toEqual(404);
+  });
+});