refactor: reduce type assertions and add test fixtures

- Remove 36 of 37 'as unknown as' type assertions across test files
- Simplify JSON fixture casts to direct type assertions
- Use proper BotEvent/EventType constants instead of string literal casts
- Replace global.fetch mock pattern with jest.mocked()

- Create test/fixtures.ts with reusable test utilities:
  - Quick event builders (quickMintEvent, quickBurnEvent, etc.)
  - Mock factories (createDiscordMock, createTwitterMock, createOpenSeaMock)
  - Environment setup helpers (setupDiscordEnv, setupTwitterEnv)
  - Twitter mock helpers (getTweetCalls, getTweetTexts)

- Simplify platform test files using new fixtures:
  - discord.test.ts: 178 → 75 lines (~58% reduction)
  - platform-event-selection.test.ts: 197 → 84 lines (~57% reduction)
  - twitter.test.ts and twitter-text.test.ts updated to use fixtures

- Update helpers.ts to document relationship with fixtures.ts

Author: ryanio

src/platforms/discord/discord.ts

@@ -40,8 +40,11 @@ export const channelsWithEvents = (): ChannelEvents => {
   for (const channel of DISCORD_EVENTS.split("&")) {
     const channelWithEvents = channel.split("=");
     const channelId = channelWithEvents[0];
-    const eventTypes = channelWithEvents[1].split(",");
-    list.push([channelId, eventTypes as unknown as (EventType | BotEvent)[]]);
+    const eventTypes = channelWithEvents[1].split(",") as (
+      | EventType
+      | BotEvent
+    )[];
+    list.push([channelId, eventTypes]);
   }
 
   return list;
@@ -176,9 +179,7 @@ const processIndividualMessages = async (
     );
   }
 
-  const messages = await messagesForEvents(
-    processableEvents as AggregatorEvent[]
-  );
+  const messages = await messagesForEvents(processableEvents);
 
   for (const [index, message] of messages.entries()) {
     const event = processableEvents[index];

src/platforms/discord/utils.ts

@@ -5,7 +5,12 @@ import {
 } from "discord.js";
 import { format } from "timeago.js";
 import { EventType, getCollectionSlug, opensea, username } from "../../opensea";
-import { BotEvent, type OpenSeaAssetEvent } from "../../types";
+import {
+  BotEvent,
+  type OpenSeaAssetEvent,
+  type OpenSeaEventType,
+  type OpenSeaOrderType,
+} from "../../types";
 import type { AggregatorEvent } from "../../utils/aggregator";
 import { MS_PER_SECOND } from "../../utils/constants";
 import {
@@ -42,8 +47,10 @@ export const escapeMarkdown = (text: string): string =>
 
 export type Field = { name: string; value: string; inline?: true };
 
-const colorFor = (eventType: EventType | BotEvent, orderType: string) =>
-  colorForEvent(eventType, orderType);
+const colorFor = (
+  eventType: EventType | BotEvent,
+  orderType: OpenSeaOrderType | undefined
+) => colorForEvent(eventType, orderType);
 
 // ---- Order/Sale/Transfer embed builders ----
 
@@ -52,7 +59,7 @@ export const buildOrderEmbed = async (
 ): Promise<{ title: string; fields: Field[] }> => {
   const { payment, order_type, expiration_date, maker, criteria } = event as {
     payment: { quantity: string; decimals: number; symbol: string };
-    order_type: string;
+    order_type: OpenSeaOrderType | string;
     expiration_date: number;
     maker: string;
     criteria: {
@@ -70,7 +77,7 @@ export const buildOrderEmbed = async (
   const inTime = expiration_date
     ? format(new Date(expiration_date * MS_PER_SECOND))
     : "Unknown";
-  if (order_type === "trait_offer") {
+  if (order_type === ("trait_offer" satisfies OpenSeaOrderType)) {
     // Get trait info from criteria - can be in trait or traits array
     const traitInfo = criteria?.trait ?? criteria?.traits?.[0];
     const traitType = traitInfo?.type ?? "Unknown";
@@ -80,15 +87,15 @@ export const buildOrderEmbed = async (
     fields.push({ name: "Price", value: price });
     fields.push({ name: "Expires", value: inTime });
   } else if (
-    order_type === "item_offer" ||
+    order_type === ("item_offer" satisfies OpenSeaOrderType) ||
     order_type === "offer" ||
     order_type === "criteria_offer"
   ) {
     title += "Item offer:";
     const price = formatAmount(quantity, decimals, symbol);
     fields.push({ name: "Price", value: price });
     fields.push({ name: "Expires", value: inTime });
-  } else if (order_type === "collection_offer") {
+  } else if (order_type === ("collection_offer" satisfies OpenSeaOrderType)) {
     title += "Collection offer";
     const price = formatAmount(quantity, decimals, symbol);
     fields.push({ name: "Price", value: price });
@@ -132,15 +139,12 @@ export const buildTransferEmbed = async (
   const fields: Field[] = [];
   if (kind === "mint") {
     // Include editions for ERC1155 mints if quantity > 1
-    const quantity = (event as unknown as { quantity?: number })?.quantity;
+    const openSeaEvent = event as OpenSeaAssetEvent;
+    const quantity = openSeaEvent.quantity;
     const tokenStandard =
-      (
-        event as unknown as {
-          nft?: { token_standard?: string };
-          asset?: { token_standard?: string };
-        }
-      )?.nft?.token_standard ??
-      (event as unknown as { asset?: { token_standard?: string } })?.asset
+      (openSeaEvent.nft as { token_standard?: string } | undefined)
+        ?.token_standard ??
+      (openSeaEvent.asset as { token_standard?: string } | undefined)
         ?.token_standard;
 
     const toName = escapeMarkdown(await username(to_address));
@@ -168,23 +172,26 @@ export const buildTransferEmbed = async (
 
 // ---- Event type classification helpers ----
 
-export const isOrderLikeType = (t: unknown, orderType?: string): boolean => {
+export const isOrderLikeType = (
+  t: unknown,
+  orderType?: OpenSeaOrderType | string
+): boolean => {
   const s = String(t);
   // Check order_type for "order" events
   if (s === "order" && orderType) {
     return (
-      orderType === "listing" ||
-      orderType === "item_offer" ||
-      orderType === "trait_offer" ||
-      orderType === "collection_offer"
+      orderType === ("listing" satisfies OpenSeaOrderType) ||
+      orderType === ("item_offer" satisfies OpenSeaOrderType) ||
+      orderType === ("trait_offer" satisfies OpenSeaOrderType) ||
+      orderType === ("collection_offer" satisfies OpenSeaOrderType)
     );
   }
   // Legacy event_type handling
   return (
     s === BotEvent.listing ||
     s === BotEvent.offer ||
-    s === "trait_offer" ||
-    s === "collection_offer" ||
+    s === ("trait_offer" satisfies OpenSeaEventType) ||
+    s === ("collection_offer" satisfies OpenSeaEventType) ||
     s === "listing"
   );
 };
@@ -269,11 +276,7 @@ export type EmbedResult = {
 export const buildEmbed = async (
   event: AggregatorEvent
 ): Promise<EmbedResult> => {
-  const { event_type, asset, order_type } = event as unknown as {
-    event_type?: EventType | string;
-    asset?: { opensea_url?: string; name?: string };
-    order_type?: string;
-  };
+  const { event_type, asset, order_type } = event;
 
   const nft = event.nft ?? asset;
   // Use effective event type to correctly identify burns, mints, etc.
@@ -287,7 +290,10 @@ export const buildEmbed = async (
 
   const built = new EmbedBuilder()
     .setColor(
-      colorFor(effectiveType, order_type ?? "") as unknown as ColorResolvable
+      colorFor(
+        effectiveType,
+        (order_type as OpenSeaOrderType | undefined) ?? undefined
+      ) as ColorResolvable
     )
     .setTitle(title)
     .setFields(

src/platforms/twitter/twitter.ts

@@ -340,7 +340,7 @@ const ensureTwitterClient = () => {
       appSecret: String(process.env.TWITTER_CONSUMER_SECRET),
       accessToken: String(process.env.TWITTER_ACCESS_TOKEN),
       accessSecret: String(process.env.TWITTER_ACCESS_TOKEN_SECRET),
-    }).readWrite as unknown as MinimalTwitterClient;
+    }).readWrite as MinimalTwitterClient;
   }
 };
 

src/platforms/twitter/utils.ts

@@ -1,5 +1,10 @@
 import { username } from "../../opensea";
-import type { OpenSeaAssetEvent, OpenSeaPayment } from "../../types";
+import type {
+  OpenSeaAssetEvent,
+  OpenSeaEventType,
+  OpenSeaOrderType,
+  OpenSeaPayment,
+} from "../../types";
 import {
   classifyTransfer,
   formatAmount,
@@ -40,28 +45,28 @@ export const formatNftName = (
 export const formatOrderText = async (
   payment: OpenSeaPayment,
   maker: string,
-  order_type: string
+  order_type: OpenSeaOrderType | string
 ) => {
   const name = await username(maker);
   const price = formatAmount(
     payment.quantity,
     payment.decimals,
     payment.symbol
   );
-  if (order_type === "listing") {
+  if (order_type === ("listing" satisfies OpenSeaOrderType)) {
     return `listed on sale for ${price} by ${name}`;
   }
   if (
-    order_type === "item_offer" ||
+    order_type === ("item_offer" satisfies OpenSeaOrderType) ||
     order_type === "offer" ||
     order_type === "criteria_offer"
   ) {
     return `has a new offer for ${price} by ${name}`;
   }
-  if (order_type === "collection_offer") {
+  if (order_type === ("collection_offer" satisfies OpenSeaOrderType)) {
     return `has a new collection offer for ${price} by ${name}`;
   }
-  if (order_type === "trait_offer") {
+  if (order_type === ("trait_offer" satisfies OpenSeaOrderType)) {
     return `has a new trait offer for ${price} by ${name}`;
   }
   return "";
@@ -101,7 +106,7 @@ export const textForOrder = async (params: {
   nft: { name?: string; identifier?: string | number } | undefined;
   payment: OpenSeaPayment;
   maker: string;
-  order_type: string;
+  order_type: OpenSeaOrderType | string;
 }): Promise<string> => {
   const { nft, payment, maker, order_type } = params;
   let text = "";
@@ -153,7 +158,7 @@ export const textForTransfer = async (
 };
 
 // Helper sets for event type classification
-const ORDER_EVENT_TYPES = new Set([
+const ORDER_EVENT_TYPES = new Set<OpenSeaEventType | "order">([
   "order",
   "listing",
   "offer",

src/types.ts

@@ -75,24 +75,32 @@ export type OpenSeaNFT = {
 // OpenSea API event_type values
 // Note: The API returns "order" for listings and all offer types
 // The actual distinction is made via the order_type field
-export type OpenSeaEventType =
-  | "sale"
-  | "transfer"
-  | "mint"
-  | "order" // Used for listings and offers - check order_type for specifics
+export const OpenSeaEventType = {
+  sale: "sale",
+  transfer: "transfer",
+  mint: "mint",
+  order: "order", // Used for listings and offers - check order_type for specifics
   // Legacy values (for backwards compatibility with existing code/tests)
-  | "listing"
-  | "offer"
-  | "trait_offer"
-  | "collection_offer";
+  listing: "listing",
+  offer: "offer",
+  trait_offer: "trait_offer",
+  collection_offer: "collection_offer",
+} as const;
+
+export type OpenSeaEventType =
+  (typeof OpenSeaEventType)[keyof typeof OpenSeaEventType];
 
 // OpenSea API order_type values (when event_type is "order")
+export const OpenSeaOrderType = {
+  listing: "listing",
+  item_offer: "item_offer",
+  trait_offer: "trait_offer",
+  collection_offer: "collection_offer",
+  criteria_offer: "criteria_offer", // Legacy value
+} as const;
+
 export type OpenSeaOrderType =
-  | "listing"
-  | "item_offer"
-  | "trait_offer"
-  | "collection_offer"
-  | "criteria_offer"; // Legacy value
+  (typeof OpenSeaOrderType)[keyof typeof OpenSeaOrderType];
 
 export type OpenSeaAssetEvent = {
   event_type: OpenSeaEventType;

src/utils/aggregator.ts

@@ -21,7 +21,7 @@ export type AggregatorEvent = {
 export const txHashFor = (event: AggregatorEvent): string | undefined =>
   (typeof event?.transaction === "string" ? event.transaction : undefined) ||
   (typeof event?.transaction === "object"
-    ? (event.transaction?.hash as string | undefined)
+    ? event.transaction?.hash
     : undefined) ||
   event?.transaction_hash ||
   event?.tx_hash ||