Skip to content

armgit / dub

Public Imported from GitHub
0

The modern link attribution platform. Loved by world-class engineering teams at Twilio, Zillow, Jobber, Vercel, Raycast, and more.

Flag applications from partners with a network-level ban (#4739)

Rafi5d469f45437a
diff --git a/apps/web/lib/actions/partners/bulk-invite-partners.ts b/apps/web/lib/actions/partners/bulk-invite-partners.ts
index 321e428bdb..a30ae90ec9 100644
--- a/apps/web/lib/actions/partners/bulk-invite-partners.ts
+++ b/apps/web/lib/actions/partners/bulk-invite-partners.ts
@@ -2,6 +2,7 @@
import { recordAuditLog } from "@/lib/api/audit-logs/record-audit-log";
import { createId } from "@/lib/api/create-id";
+import { detectAndRecordNetworkLevelBans } from "@/lib/api/fraud/detect-network-level-bans";
import { bulkCreateLinks } from "@/lib/api/links";
import { getGroupRewardsAndBounties } from "@/lib/api/partners/get-group-rewards-and-bounties";
import { queuePartnerSearchSync } from "@/lib/api/partners/queue-partner-search-sync";
@@ -175,6 +176,13 @@ export const bulkInvitePartnersAction = authActionClient
waitUntil(
(async () => {
+ // Check for network-level bans before the default links are created,
+ // so a link failure does not skip the check
+ await detectAndRecordNetworkLevelBans({
+ programId,
+ partnerIds: partners.map(({ id }) => id),
+ });
+
// Create default links for the partners for each group default link
for (const partnerGroupDefaultLink of partnerGroupDefaultLinks) {
const links = await bulkCreateLinks({
diff --git a/apps/web/lib/actions/partners/create-program-application.ts b/apps/web/lib/actions/partners/create-program-application.ts
index 9e3d5cffac..87a3e8ad89 100644
--- a/apps/web/lib/actions/partners/create-program-application.ts
+++ b/apps/web/lib/actions/partners/create-program-application.ts
@@ -458,6 +458,16 @@ async function createApplicationAndEnrollment({
applications: [programApplication],
});
+ // Detect and record fraud events for the partner when they apply to a program
+ const fraudDetection = detectAndRecordFraudApplication({
+ context: {
+ program,
+ partner,
+ },
+ }).catch((error) =>
+ console.error("Failed to detect application fraud", error),
+ );
+
await Promise.allSettled([
notifyProgramApplication({
partner,
@@ -469,15 +479,18 @@ async function createApplicationAndEnrollment({
...(result.reason === "requirementsNotMet"
? []
: [
- dispatchPartnerApplicationReview({
- applicationId: programApplication.id,
- programId: program.id,
- partnerId: partner.id,
- autoApprovePartnersEnabledAt:
- group.autoApprovePartnersEnabledAt,
- applicationScreeningCriteria:
- program.applicationScreeningCriteria,
- }),
+ // Wait for fraud detection, so the review job sees the new fraud events
+ fraudDetection.then(() =>
+ dispatchPartnerApplicationReview({
+ applicationId: programApplication.id,
+ programId: program.id,
+ partnerId: partner.id,
+ autoApprovePartnersEnabledAt:
+ group.autoApprovePartnersEnabledAt,
+ applicationScreeningCriteria:
+ program.applicationScreeningCriteria,
+ }),
+ ),
]),
// Send "partner.application_submitted" webhook (deprecated)
@@ -507,13 +520,7 @@ async function createApplicationAndEnrollment({
}),
}),
- // Detect and record fraud events for the partner when they apply to a program
- detectAndRecordFraudApplication({
- context: {
- program,
- partner,
- },
- }),
+ fraudDetection,
markApplicationEventSubmitted({
programId: program.id,
diff --git a/apps/web/lib/api/fraud/confirm-partner-fraud-alerts.ts b/apps/web/lib/api/fraud/confirm-partner-fraud-alerts.ts
index 92191e0a7d..d679f68282 100644
--- a/apps/web/lib/api/fraud/confirm-partner-fraud-alerts.ts
+++ b/apps/web/lib/api/fraud/confirm-partner-fraud-alerts.ts
@@ -1,4 +1,7 @@
-import { reportNetworkLevelBan } from "@/lib/api/fraud/report-network-level-ban";
+import {
+ getNetworkBanDetails,
+ reportNetworkLevelBan,
+} from "@/lib/api/fraud/report-network-level-ban";
import { prisma } from "@/lib/prisma";
export async function confirmPartnerFraudAlerts({
@@ -53,11 +56,12 @@ export async function confirmPartnerFraudAlerts({
reviewedAt,
},
select: {
+ programId: true,
+ source: true,
+ reviewedAt: true,
createdAt: true,
programEnrollment: {
select: {
- programId: true,
- partnerId: true,
bannedReason: true,
bannedAt: true,
application: {
@@ -71,17 +75,17 @@ export async function confirmPartnerFraudAlerts({
});
const alertResults = await Promise.allSettled(
- confirmedFraudAlerts.map(({ programEnrollment, createdAt }) =>
- reportNetworkLevelBan({
- partnerId: programEnrollment.partnerId,
- programId: programEnrollment.programId,
- bannedReason: programEnrollment.bannedReason ?? "fraud",
- bannedAt:
- programEnrollment.bannedAt ??
- programEnrollment.application?.reviewedAt ??
- createdAt,
- }),
- ),
+ confirmedFraudAlerts.map((fraudAlert) => {
+ const { sourceProgramId, bannedReason, bannedAt } =
+ getNetworkBanDetails(fraudAlert);
+
+ return reportNetworkLevelBan({
+ partnerId,
+ programId: sourceProgramId,
+ bannedReason,
+ bannedAt,
+ });
+ }),
);
const failedReports = alertResults.filter(
diff --git a/apps/web/lib/api/fraud/detect-network-level-bans.ts b/apps/web/lib/api/fraud/detect-network-level-bans.ts
new file mode 100644
index 0000000000..1fd7d7e8ac
--- /dev/null
+++ b/apps/web/lib/api/fraud/detect-network-level-bans.ts
@@ -0,0 +1,140 @@
+import { prisma } from "@/lib/prisma";
+import { CreateFraudEventInput } from "@/lib/types";
+import { INACTIVE_ENROLLMENT_STATUSES } from "@/lib/zod/schemas/partners";
+import { FraudRuleType, ProgramEnrollmentStatus } from "@prisma/client";
+import { createFraudEvents } from "./create-fraud-events";
+import { isFraudRuleEnabled } from "./get-merged-fraud-rules";
+import { getNetworkBanDetails } from "./report-network-level-ban";
+
+// Returns partnerCrossProgramBan fraud events for the partners that have a confirmed network-level
+// ban. reportNetworkLevelBan only alerts programs the partner was enrolled in at ban time, so a
+// program the partner joins later must be alerted when the enrollment is created.
+export async function getNetworkLevelBanEvents({
+ programId,
+ partnerIds,
+}: {
+ programId: string;
+ partnerIds: string[];
+}) {
+ const fraudEvents: CreateFraudEventInput[] = [];
+
+ if (partnerIds.length === 0) {
+ return fraudEvents;
+ }
+
+ const confirmedFraudAlerts = await prisma.fraudAlert.findMany({
+ where: {
+ partnerId: {
+ in: partnerIds,
+ },
+ status: "confirmed",
+ // An unban removes the cross-program ban events from that program,
+ // so skip program bans that were lifted
+ OR: [
+ { source: "admin" },
+ {
+ programEnrollment: {
+ status: ProgramEnrollmentStatus.banned,
+ },
+ },
+ ],
+ // Only alert active enrollments with risk monitoring on, the same as reportNetworkLevelBan
+ partner: {
+ programs: {
+ some: {
+ programId,
+ status: {
+ notIn: INACTIVE_ENROLLMENT_STATUSES,
+ },
+ riskMonitoringDisabledAt: null,
+ },
+ },
+ },
+ },
+ select: {
+ partnerId: true,
+ programId: true,
+ source: true,
+ reviewedAt: true,
+ createdAt: true,
+ programEnrollment: {
+ select: {
+ bannedReason: true,
+ bannedAt: true,
+ application: {
+ select: {
+ reviewedAt: true,
+ },
+ },
+ },
+ },
+ },
+ });
+
+ for (const fraudAlert of confirmedFraudAlerts) {
+ const { sourceProgramId, bannedReason, bannedAt } =
+ getNetworkBanDetails(fraudAlert);
+
+ // Skip bans issued by this program. Admin bans come from the network program.
+ if (sourceProgramId === programId) {
+ continue;
+ }
+
+ fraudEvents.push({
+ programId,
+ partnerId: fraudAlert.partnerId,
+ type: FraudRuleType.partnerCrossProgramBan,
+ sourceProgramId,
+ metadata: {
+ bannedReason,
+ bannedAt,
+ },
+ });
+ }
+
+ return fraudEvents;
+}
+
+// Detect and record network-level bans for partners that a program enrolled without an application
+// (invites, the partners API, imports). Errors are logged, so they never block the enrollment.
+export async function detectAndRecordNetworkLevelBans({
+ programId,
+ partnerIds,
+}: {
+ programId: string;
+ partnerIds: string[];
+}) {
+ if (partnerIds.length === 0) {
+ return;
+ }
+
+ try {
+ const fraudRules = await prisma.fraudRule.findMany({
+ where: {
+ programId,
+ },
+ });
+
+ if (
+ !isFraudRuleEnabled({
+ fraudRules,
+ ruleType: FraudRuleType.partnerCrossProgramBan,
+ })
+ ) {
+ return;
+ }
+
+ const fraudEvents = await getNetworkLevelBanEvents({
+ programId,
+ partnerIds,
+ });
+
+ await createFraudEvents(fraudEvents);
+ } catch (error) {
+ console.error(
+ "Failed to detect network-level bans for program",
+ programId,
+ error,
+ );
+ }
+}
diff --git a/apps/web/lib/api/fraud/detect-record-fraud-application.ts b/apps/web/lib/api/fraud/detect-record-fraud-application.ts
index 7d8eb5eddd..da3a744ced 100644
--- a/apps/web/lib/api/fraud/detect-record-fraud-application.ts
+++ b/apps/web/lib/api/fraud/detect-record-fraud-application.ts
@@ -3,6 +3,7 @@ import { CreateFraudEventInput, PartnerProps, ProgramProps } from "@/lib/types";
import { INACTIVE_ENROLLMENT_STATUSES } from "@/lib/zod/schemas/partners";
import { FraudRuleType } from "@prisma/client";
import { createFraudEvents } from "./create-fraud-events";
+import { getNetworkLevelBanEvents } from "./detect-network-level-bans";
import { isFraudRuleEnabled } from "./get-merged-fraud-rules";
interface FraudApplicationContext {
@@ -13,87 +14,111 @@ interface FraudApplicationContext {
};
}
-// Detect and record fraud events for the partner when they apply to a program (partnerDuplicateAccount fraud rule)
+// Detect and record fraud events for the partner when they apply to a program
+// (partnerDuplicateAccount and partnerCrossProgramBan fraud rules)
export async function detectAndRecordFraudApplication({
- context: { program, partner },
+ context,
}: {
context: FraudApplicationContext;
}) {
- const fraudEvents: CreateFraudEventInput[] = [];
-
const fraudRules = await prisma.fraudRule.findMany({
where: {
- programId: program.id,
+ programId: context.program.id,
},
});
- // Check if partner shares the same payoutMethodHash or cryptoWalletAddress with other partners
- // indicates potential duplicate account fraud
- if (
+ // The checks do not depend on each other, so run them in parallel
+ const fraudEvents = await Promise.all([
isFraudRuleEnabled({
fraudRules,
ruleType: FraudRuleType.partnerDuplicateAccount,
})
- ) {
- const { payoutMethodHash, cryptoWalletAddress } = partner;
+ ? detectDuplicateAccounts(context)
+ : [],
+
+ isFraudRuleEnabled({
+ fraudRules,
+ ruleType: FraudRuleType.partnerCrossProgramBan,
+ })
+ ? getNetworkLevelBanEvents({
+ programId: context.program.id,
+ partnerIds: [context.partner.id],
+ })
+ : [],
+ ]);
+
+ await createFraudEvents(fraudEvents.flat());
+}
+
+// Check if partner shares the same payoutMethodHash or cryptoWalletAddress with other partners
+// indicates potential duplicate account fraud
+async function detectDuplicateAccounts({
+ program,
+ partner,
+}: FraudApplicationContext) {
+ const fraudEvents: CreateFraudEventInput[] = [];
+ const { payoutMethodHash, cryptoWalletAddress } = partner;
+
+ if (!payoutMethodHash && !cryptoWalletAddress) {
+ return fraudEvents;
+ }
- if (payoutMethodHash || cryptoWalletAddress) {
- const duplicatePartners = await prisma.partner.findMany({
+ const duplicatePartners = await prisma.partner.findMany({
+ where: {
+ programs: {
+ some: {
+ programId: program.id,
+ },
+ },
+ OR: [
+ ...(payoutMethodHash ? [{ payoutMethodHash }] : []),
+ ...(cryptoWalletAddress ? [{ cryptoWalletAddress }] : []),
+ ],
+ },
+ select: {
+ id: true,
+ payoutMethodHash: true,
+ cryptoWalletAddress: true,
+ programs: {
where: {
- programs: {
- some: {
- programId: program.id,
- },
- },
- OR: [
- ...(payoutMethodHash ? [{ payoutMethodHash }] : []),
- ...(cryptoWalletAddress ? [{ cryptoWalletAddress }] : []),
- ],
+ programId: program.id,
},
select: {
- id: true,
- payoutMethodHash: true,
- cryptoWalletAddress: true,
- programs: {
- where: {
- programId: program.id,
- },
- select: {
- status: true,
- riskMonitoringDisabledAt: true,
- },
- },
+ status: true,
+ riskMonitoringDisabledAt: true,
},
- });
+ },
+ },
+ });
- if (duplicatePartners.length > 1) {
- for (const sourcePartner of duplicatePartners) {
- const programEnrollment = sourcePartner.programs[0];
+ if (duplicatePartners.length <= 1) {
+ return fraudEvents;
+ }
+
+ for (const sourcePartner of duplicatePartners) {
+ const programEnrollment = sourcePartner.programs[0];
- // Skip if the partner is inactive or risk detection is disabled
- if (
- INACTIVE_ENROLLMENT_STATUSES.includes(programEnrollment.status) ||
- programEnrollment.riskMonitoringDisabledAt
- ) {
- continue;
- }
+ // Skip if the partner is inactive or risk detection is disabled
+ if (
+ INACTIVE_ENROLLMENT_STATUSES.includes(programEnrollment.status) ||
+ programEnrollment.riskMonitoringDisabledAt
+ ) {
+ continue;
+ }
- for (const conflictingPartner of duplicatePartners) {
- fraudEvents.push({
- programId: program.id,
- partnerId: sourcePartner.id,
- type: FraudRuleType.partnerDuplicateAccount,
- metadata: {
- ...(payoutMethodHash ? { payoutMethodHash } : {}),
- ...(cryptoWalletAddress ? { cryptoWalletAddress } : {}),
- duplicatePartnerId: conflictingPartner.id,
- },
- });
- }
- }
- }
+ for (const conflictingPartner of duplicatePartners) {
+ fraudEvents.push({
+ programId: program.id,
+ partnerId: sourcePartner.id,
+ type: FraudRuleType.partnerDuplicateAccount,
+ metadata: {
+ ...(payoutMethodHash ? { payoutMethodHash } : {}),
+ ...(cryptoWalletAddress ? { cryptoWalletAddress } : {}),
+ duplicatePartnerId: conflictingPartner.id,
+ },
+ });
}
}
- await createFraudEvents(fraudEvents);
+ return fraudEvents;
}
diff --git a/apps/web/lib/api/fraud/report-network-level-ban.ts b/apps/web/lib/api/fraud/report-network-level-ban.ts
index 0b5761ead3..b89d425eff 100644
--- a/apps/web/lib/api/fraud/report-network-level-ban.ts
+++ b/apps/web/lib/api/fraud/report-network-level-ban.ts
@@ -2,10 +2,53 @@ import { createFraudEvents } from "@/lib/api/fraud/create-fraud-events";
import { isFraudRuleEnabled } from "@/lib/api/fraud/get-merged-fraud-rules";
import { prisma } from "@/lib/prisma";
import { INACTIVE_ENROLLMENT_STATUSES } from "@/lib/zod/schemas/partners";
-import { FraudRuleType, PartnerBannedReason } from "@prisma/client";
+import { NETWORK_PROGRAM_ID } from "@dub/utils";
+import {
+ FraudAlert,
+ FraudRuleType,
+ PartnerBannedReason,
+ ProgramApplication,
+ ProgramEnrollment,
+} from "@prisma/client";
import { holdPendingCommissions } from "./hold-pending-commissions";
import { holdProcessedCommissions } from "./hold-processed-commissions";
+type NetworkBanFraudAlert = Pick<
+ FraudAlert,
+ "programId" | "source" | "reviewedAt" | "createdAt"
+> & {
+ programEnrollment: Pick<ProgramEnrollment, "bannedReason" | "bannedAt"> & {
+ application: Pick<ProgramApplication, "reviewedAt"> | null;
+ };
+};
+
+// Returns the source program and ban details that a confirmed fraud alert reports to other programs.
+// Admin bans come from the network program, because no program banned the partner.
+export function getNetworkBanDetails(fraudAlert: NetworkBanFraudAlert): {
+ sourceProgramId: string;
+ bannedReason: PartnerBannedReason;
+ bannedAt: Date;
+} {
+ if (fraudAlert.source === "admin") {
+ return {
+ sourceProgramId: NETWORK_PROGRAM_ID,
+ bannedReason: "fraud",
+ bannedAt: fraudAlert.reviewedAt ?? fraudAlert.createdAt,
+ };
+ }
+
+ const { programEnrollment } = fraudAlert;
+
+ return {
+ sourceProgramId: fraudAlert.programId,
+ bannedReason: programEnrollment.bannedReason ?? "fraud",
+ bannedAt:
+ programEnrollment.bannedAt ??
+ programEnrollment.application?.reviewedAt ??
+ fraudAlert.createdAt,
+ };
+}
+
// Creates partnerCrossProgramBan fraud events in other programs where the partner is enrolled.
// Used when a program bans a partner so that other programs can be alerted about network-level
// fraud risk. Only programs with the partnerCrossProgramBan rule enabled receive events.
diff --git a/apps/web/lib/api/partners/create-and-enroll-partner.ts b/apps/web/lib/api/partners/create-and-enroll-partner.ts
index d914398d77..f9fd9c0a12 100644
--- a/apps/web/lib/api/partners/create-and-enroll-partner.ts
+++ b/apps/web/lib/api/partners/create-and-enroll-partner.ts
@@ -12,6 +12,7 @@ import { nanoid } from "@dub/utils";
import { ProgramEnrollmentStatus } from "@prisma/client";
import { waitUntil } from "@vercel/functions";
import { DubApiError } from "../errors";
+import { detectAndRecordNetworkLevelBans } from "../fraud/detect-network-level-bans";
import { getGroupOrThrow } from "../groups/get-group-or-throw";
import { throwIfInvalidPartnerTags } from "../partner-tags/throw-if-invalid-partner-tags";
import {
@@ -216,6 +217,15 @@ export const createAndEnrollPartner = async ({
// Queue an index update because a new enrollment was created.
waitUntil(queuePartnerSearchSync({ enrollmentIds: [programEnrollment.id] }));
+ // Check for a network-level ban before the default links are created,
+ // so a link failure does not skip it
+ waitUntil(
+ detectAndRecordNetworkLevelBans({
+ programId: program.id,
+ partnerIds: [existingOrNewPartner.id],
+ }),
+ );
+
// Create the partner links based on group defaults
const links = await createPartnerDefaultLinks({
workspace: {
diff --git a/apps/web/lib/firstpromoter/import-partners.ts b/apps/web/lib/firstpromoter/import-partners.ts
index 5c43c58a6b..8634bf83db 100644
--- a/apps/web/lib/firstpromoter/import-partners.ts
+++ b/apps/web/lib/firstpromoter/import-partners.ts
@@ -7,6 +7,7 @@ import {
Program,
} from "@prisma/client";
import { createId } from "../api/create-id";
+import { detectAndRecordNetworkLevelBans } from "../api/fraud/detect-network-level-bans";
import { bulkCreateLinks } from "../api/links";
import { upsertPartnerPlatform } from "../api/partner-profile/upsert-partner-platform";
import { queuePartnerSearchSync } from "../api/partners/queue-partner-search-sync";
@@ -93,12 +94,19 @@ export async function importPartners(payload: FirstPromoterImportPayload) {
}
});
+ const programEnrollments = results.flatMap((result) =>
+ result.status === "fulfilled" && result.value ? [result.value] : [],
+ );
+
// Queue an index update because the imported partners were enrolled.
// Queued per page rather than per partner.
await queuePartnerSearchSync({
- enrollmentIds: results.flatMap((result) =>
- result.status === "fulfilled" && result.value ? [result.value] : [],
- ),
+ enrollmentIds: programEnrollments.map(({ id }) => id),
+ });
+
+ await detectAndRecordNetworkLevelBans({
+ programId: program.id,
+ partnerIds: programEnrollments.map(({ partnerId }) => partnerId),
});
}
@@ -212,16 +220,16 @@ async function createPartnerAndLinks({
if (!program.domain || !program.url) {
console.error("Program domain or url not found", program.id);
- return programEnrollment.id;
+ return programEnrollment;
}
if (preservedBan) {
- return programEnrollment.id;
+ return programEnrollment;
}
if (programEnrollment.links.length > 0) {
console.log("Partner already has links", partner.id);
- return programEnrollment.id;
+ return programEnrollment;
}
const links = affiliate.promoter_campaigns.map((campaign, idx) => ({
@@ -243,7 +251,7 @@ async function createPartnerAndLinks({
links,
});
} catch (error) {
- // The enrollment is already committed, so its ID must still reach the
+ // The enrollment is already committed, so it must still reach the
// page-level search sync even when link creation fails.
console.error(
`Failed to create links for imported affiliate ${affiliate.id}`,
@@ -251,5 +259,5 @@ async function createPartnerAndLinks({
);
}
- return programEnrollment.id;
+ return programEnrollment;
}
diff --git a/apps/web/lib/lemonsqueezy/import-partners.ts b/apps/web/lib/lemonsqueezy/import-partners.ts
index 68f71e1df1..385eed41bd 100644
--- a/apps/web/lib/lemonsqueezy/import-partners.ts
+++ b/apps/web/lib/lemonsqueezy/import-partners.ts
@@ -1,6 +1,7 @@
import { prisma } from "@/lib/prisma";
import { PartnerGroup, Program } from "@prisma/client";
import { createId } from "../api/create-id";
+import { detectAndRecordNetworkLevelBans } from "../api/fraud/detect-network-level-bans";
import { createLink } from "../api/links";
import { generatePartnerLink } from "../api/partners/generate-partner-link";
import { queuePartnerSearchSync } from "../api/partners/queue-partner-search-sync";
@@ -141,13 +142,20 @@ export async function importPartners(payload: LemonSqueezyImportPayload) {
);
}
+ const partnerIds = results.flatMap((result) =>
+ result.status === "fulfilled" && result.value ? [result.value] : [],
+ );
+
// Queue an index update because the imported partners were enrolled.
// Queued per page rather than per partner.
await queuePartnerSearchSync({
- partnerIds: results.flatMap((result) =>
- result.status === "fulfilled" && result.value ? [result.value] : [],
- ),
+ partnerIds,
+ programId: program.id,
+ });
+
+ await detectAndRecordNetworkLevelBans({
programId: program.id,
+ partnerIds,
});
}
diff --git a/apps/web/lib/partners/complete-program-applications.ts b/apps/web/lib/partners/complete-program-applications.ts
index 5a028c89b7..0cffb2f985 100644
--- a/apps/web/lib/partners/complete-program-applications.ts
+++ b/apps/web/lib/partners/complete-program-applications.ts
@@ -214,6 +214,16 @@ export async function completeProgramApplications(userEmail: string) {
},
};
+ // Detect and record fraud events for the partner when they apply to a program
+ const fraudDetection = detectAndRecordFraudApplication({
+ context: {
+ program,
+ partner,
+ },
+ }).catch((error) =>
+ console.error("Failed to detect application fraud", error),
+ );
+
await Promise.allSettled([
...(validApplication
? [
@@ -224,15 +234,18 @@ export async function completeProgramApplications(userEmail: string) {
application,
}),
- dispatchPartnerApplicationReview({
- applicationId: application.id,
- programId: program.id,
- partnerId: partner.id,
- autoApprovePartnersEnabledAt:
- group?.autoApprovePartnersEnabledAt,
- applicationScreeningCriteria:
- program.applicationScreeningCriteria,
- }),
+ // Wait for fraud detection, so the review job sees the new fraud events
+ fraudDetection.then(() =>
+ dispatchPartnerApplicationReview({
+ applicationId: application.id,
+ programId: program.id,
+ partnerId: partner.id,
+ autoApprovePartnersEnabledAt:
+ group?.autoApprovePartnersEnabledAt,
+ applicationScreeningCriteria:
+ program.applicationScreeningCriteria,
+ }),
+ ),
// Send "partner.application_submitted" webhook (deprecated)
workspacesByProgramId.has(program.id) &&
@@ -275,13 +288,7 @@ export async function completeProgramApplications(userEmail: string) {
),
]),
- // Detect and record fraud events for the partner when they apply to a program
- detectAndRecordFraudApplication({
- context: {
- program,
- partner,
- },
- }),
+ fraudDetection,
]);
}),
);
diff --git a/apps/web/lib/partnerstack/import-partners.ts b/apps/web/lib/partnerstack/import-partners.ts
index 0bf90448f6..8720c221dc 100644
--- a/apps/web/lib/partnerstack/import-partners.ts
+++ b/apps/web/lib/partnerstack/import-partners.ts
@@ -2,6 +2,7 @@ import { prisma } from "@/lib/prisma";
import { COUNTRIES, COUNTRY_CODES, sleep } from "@dub/utils";
import { PartnerGroup, Program } from "@prisma/client";
import { createId } from "../api/create-id";
+import { detectAndRecordNetworkLevelBans } from "../api/fraud/detect-network-level-bans";
import { queuePartnerSearchSync } from "../api/partners/queue-partner-search-sync";
import { upsertImportedProgramEnrollment } from "../api/partners/upsert-imported-program-enrollment";
import { approveLinkedApplication } from "../program-applications/approve-linked-application";
@@ -70,13 +71,20 @@ export async function importPartners(payload: PartnerStackImportPayload) {
),
);
+ const partnerIds = results.flatMap((result) =>
+ result.status === "fulfilled" && result.value ? [result.value] : [],
+ );
+
// Queue an index update because the imported partners were enrolled. Queued
// per page rather than per partner.
await queuePartnerSearchSync({
- partnerIds: results.flatMap((result) =>
- result.status === "fulfilled" && result.value ? [result.value] : [],
- ),
+ partnerIds,
+ programId,
+ });
+
+ await detectAndRecordNetworkLevelBans({
programId,
+ partnerIds,
});
await sleep(2000);
diff --git a/apps/web/lib/rewardful/import-partners.ts b/apps/web/lib/rewardful/import-partners.ts
index 83d3f5c013..4116d50cd0 100644
--- a/apps/web/lib/rewardful/import-partners.ts
+++ b/apps/web/lib/rewardful/import-partners.ts
@@ -2,6 +2,7 @@ import { prisma } from "@/lib/prisma";
import { nanoid } from "@dub/utils";
import { Program } from "@prisma/client";
import { createId } from "../api/create-id";
+import { detectAndRecordNetworkLevelBans } from "../api/fraud/detect-network-level-bans";
import { bulkCreateLinks } from "../api/links";
import { queuePartnerSearchSync } from "../api/partners/queue-partner-search-sync";
import { upsertImportedProgramEnrollment } from "../api/partners/upsert-imported-program-enrollment";
@@ -141,6 +142,11 @@ export async function importPartners(payload: RewardfulImportPayload) {
partnerIds: filteredPartners.map((p) => p.dubPartnerId),
programId: program.id,
});
+
+ await detectAndRecordNetworkLevelBans({
+ programId: program.id,
+ partnerIds: filteredPartners.map((p) => p.dubPartnerId),
+ });
}
}
diff --git a/apps/web/lib/tapfiliate/import-partners.ts b/apps/web/lib/tapfiliate/import-partners.ts
index 08c41c4256..c2d3f7c5a9 100644
--- a/apps/web/lib/tapfiliate/import-partners.ts
+++ b/apps/web/lib/tapfiliate/import-partners.ts
@@ -2,6 +2,7 @@ import { prisma } from "@/lib/prisma";
import { PartnerGroup, Program } from "@prisma/client";
import slugify from "@sindresorhus/slugify";
import { createId } from "../api/create-id";
+import { detectAndRecordNetworkLevelBans } from "../api/fraud/detect-network-level-bans";
import { createLink } from "../api/links";
import { generatePartnerLink } from "../api/partners/generate-partner-link";
import { queuePartnerSearchSync } from "../api/partners/queue-partner-search-sync";
@@ -120,6 +121,8 @@ export async function importPartners(payload: TapfiliateImportPayload) {
// Queued per page rather than per partner.
await queuePartnerSearchSync({ partnerIds, programId });
+ await detectAndRecordNetworkLevelBans({ programId, partnerIds });
+
await tapfiliateImporter.trackImportedPartnerIds({
programId,
partnerIds,
diff --git a/apps/web/lib/tolt/import-partners.ts b/apps/web/lib/tolt/import-partners.ts
index 698d0a079b..1c790abad8 100644
--- a/apps/web/lib/tolt/import-partners.ts
+++ b/apps/web/lib/tolt/import-partners.ts
@@ -3,6 +3,7 @@ import { sleep } from "@dub/utils";
import { Partner, Program } from "@prisma/client";
import { createId } from "../api/create-id";
+import { detectAndRecordNetworkLevelBans } from "../api/fraud/detect-network-level-bans";
import { queuePartnerSearchSync } from "../api/partners/queue-partner-search-sync";
import { upsertImportedProgramEnrollment } from "../api/partners/upsert-imported-program-enrollment";
import { approveLinkedApplication } from "../program-applications/approve-linked-application";
@@ -98,6 +99,11 @@ export async function importPartners(payload: ToltImportPayload) {
programId,
});
+ await detectAndRecordNetworkLevelBans({
+ programId,
+ partnerIds: partners.map((p) => p.id),
+ });
+
await toltImporter.addPartners({
programId,
partnerIds: partners.map((p) => p.id),
diff --git a/apps/web/tests/fraud/detect-network-level-bans.test.ts b/apps/web/tests/fraud/detect-network-level-bans.test.ts
new file mode 100644
index 0000000000..c0a3291c25
--- /dev/null
+++ b/apps/web/tests/fraud/detect-network-level-bans.test.ts
@@ -0,0 +1,135 @@
+import { detectAndRecordNetworkLevelBans } from "@/lib/api/fraud/detect-network-level-bans";
+import { INACTIVE_ENROLLMENT_STATUSES } from "@/lib/zod/schemas/partners";
+import { FraudRuleType } from "@prisma/client";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+ fraudRuleFindMany: vi.fn(),
+ fraudAlertFindMany: vi.fn(),
+ createFraudEvents: vi.fn(),
+}));
+
+vi.mock("server-only", () => ({}));
+
+vi.mock("@/lib/prisma", () => ({
+ prisma: {
+ fraudRule: { findMany: mocks.fraudRuleFindMany },
+ fraudAlert: { findMany: mocks.fraudAlertFindMany },
+ },
+}));
+
+vi.mock("@/lib/api/fraud/create-fraud-events", () => ({
+ createFraudEvents: mocks.createFraudEvents,
+}));
+
+const PROGRAM_ID = "prog_inviting";
+const BANNING_PROGRAM_ID = "prog_banning";
+const BANNED_PARTNER_ID = "pn_banned";
+const CLEAN_PARTNER_ID = "pn_clean";
+const BANNED_AT = new Date("2026-10-01");
+
+const programBanAlert = {
+ partnerId: BANNED_PARTNER_ID,
+ programId: BANNING_PROGRAM_ID,
+ source: "program",
+ reviewedAt: BANNED_AT,
+ createdAt: BANNED_AT,
+ programEnrollment: {
+ bannedReason: "fraud",
+ bannedAt: BANNED_AT,
+ application: null,
+ },
+};
+
+describe("detectAndRecordNetworkLevelBans", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mocks.fraudRuleFindMany.mockResolvedValue([]);
+ mocks.fraudAlertFindMany.mockResolvedValue([]);
+ });
+
+ it("checks all enrolled partners in one query and flags the banned ones", async () => {
+ mocks.fraudAlertFindMany.mockResolvedValue([programBanAlert]);
+
+ await detectAndRecordNetworkLevelBans({
+ programId: PROGRAM_ID,
+ partnerIds: [BANNED_PARTNER_ID, CLEAN_PARTNER_ID],
+ });
+
+ expect(mocks.fraudAlertFindMany).toHaveBeenCalledTimes(1);
+ expect(mocks.fraudAlertFindMany).toHaveBeenCalledWith(
+ expect.objectContaining({
+ where: expect.objectContaining({
+ partnerId: { in: [BANNED_PARTNER_ID, CLEAN_PARTNER_ID] },
+ status: "confirmed",
+ // Only active enrollments with risk monitoring on are alerted
+ partner: {
+ programs: {
+ some: {
+ programId: PROGRAM_ID,
+ status: { notIn: INACTIVE_ENROLLMENT_STATUSES },
+ riskMonitoringDisabledAt: null,
+ },
+ },
+ },
+ }),
+ }),
+ );
+ expect(mocks.createFraudEvents).toHaveBeenCalledWith([
+ {
+ programId: PROGRAM_ID,
+ partnerId: BANNED_PARTNER_ID,
+ type: FraudRuleType.partnerCrossProgramBan,
+ sourceProgramId: BANNING_PROGRAM_ID,
+ metadata: {
+ bannedReason: "fraud",
+ bannedAt: BANNED_AT,
+ },
+ },
+ ]);
+ });
+
+ it("does nothing when no partners were enrolled", async () => {
+ await detectAndRecordNetworkLevelBans({
+ programId: PROGRAM_ID,
+ partnerIds: [],
+ });
+
+ expect(mocks.fraudRuleFindMany).not.toHaveBeenCalled();
+ expect(mocks.fraudAlertFindMany).not.toHaveBeenCalled();
+ expect(mocks.createFraudEvents).not.toHaveBeenCalled();
+ });
+
+ it("does not check bans when the rule is disabled", async () => {
+ mocks.fraudRuleFindMany.mockResolvedValue([
+ {
+ programId: PROGRAM_ID,
+ type: FraudRuleType.partnerCrossProgramBan,
+ disabledAt: new Date(),
+ config: null,
+ },
+ ]);
+
+ await detectAndRecordNetworkLevelBans({
+ programId: PROGRAM_ID,
+ partnerIds: [BANNED_PARTNER_ID],
+ });
+
+ expect(mocks.fraudAlertFindMany).not.toHaveBeenCalled();
+ expect(mocks.createFraudEvents).not.toHaveBeenCalled();
+ });
+
+ it("does not throw when the check fails, so the enrollment is not blocked", async () => {
+ vi.spyOn(console, "error").mockImplementation(() => {});
+ mocks.fraudAlertFindMany.mockRejectedValue(new Error("Database error"));
+
+ await expect(
+ detectAndRecordNetworkLevelBans({
+ programId: PROGRAM_ID,
+ partnerIds: [BANNED_PARTNER_ID],
+ }),
+ ).resolves.toBeUndefined();
+
+ expect(mocks.createFraudEvents).not.toHaveBeenCalled();
+ });
+});
diff --git a/apps/web/tests/fraud/detect-record-fraud-application.test.ts b/apps/web/tests/fraud/detect-record-fraud-application.test.ts
new file mode 100644
index 0000000000..26b8cc9cf0
--- /dev/null
+++ b/apps/web/tests/fraud/detect-record-fraud-application.test.ts
@@ -0,0 +1,176 @@
+import { detectAndRecordFraudApplication } from "@/lib/api/fraud/detect-record-fraud-application";
+import { NETWORK_PROGRAM_ID } from "@dub/utils";
+import { FraudRuleType, ProgramEnrollmentStatus } from "@prisma/client";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+ fraudRuleFindMany: vi.fn(),
+ fraudAlertFindMany: vi.fn(),
+ createFraudEvents: vi.fn(),
+}));
+
+vi.mock("server-only", () => ({}));
+
+vi.mock("@/lib/prisma", () => ({
+ prisma: {
+ fraudRule: { findMany: mocks.fraudRuleFindMany },
+ fraudAlert: { findMany: mocks.fraudAlertFindMany },
+ },
+}));
+
+vi.mock("@/lib/api/fraud/create-fraud-events", () => ({
+ createFraudEvents: mocks.createFraudEvents,
+}));
+
+const PROGRAM_ID = "prog_applying";
+const BANNING_PROGRAM_ID = "prog_banning";
+const PARTNER_ID = "pn_banned";
+const BANNED_AT = new Date("2026-10-01");
+const REVIEWED_AT = new Date("2026-10-02");
+
+const context = {
+ program: { id: PROGRAM_ID },
+ partner: {
+ id: PARTNER_ID,
+ payoutMethodHash: null,
+ cryptoWalletAddress: null,
+ },
+};
+
+const programBanAlert = {
+ partnerId: PARTNER_ID,
+ programId: BANNING_PROGRAM_ID,
+ source: "program",
+ reviewedAt: REVIEWED_AT,
+ createdAt: BANNED_AT,
+ programEnrollment: {
+ bannedReason: "tos_violation",
+ bannedAt: BANNED_AT,
+ application: null,
+ },
+};
+
+const adminBanAlert = {
+ partnerId: PARTNER_ID,
+ programId: BANNING_PROGRAM_ID,
+ source: "admin",
+ reviewedAt: REVIEWED_AT,
+ createdAt: BANNED_AT,
+ programEnrollment: {
+ bannedReason: null,
+ bannedAt: null,
+ application: null,
+ },
+};
+
+function createdEvents() {
+ return mocks.createFraudEvents.mock.calls[0][0];
+}
+
+describe("detectAndRecordFraudApplication", () => {
+ beforeEach(() => {
+ vi.clearAllMocks();
+ mocks.fraudRuleFindMany.mockResolvedValue([]);
+ mocks.fraudAlertFindMany.mockResolvedValue([]);
+ });
+
+ it("flags an applicant with a confirmed program ban", async () => {
+ mocks.fraudAlertFindMany.mockResolvedValue([programBanAlert]);
+
+ await detectAndRecordFraudApplication({ context });
+
+ expect(mocks.fraudAlertFindMany).toHaveBeenCalledWith(
+ expect.objectContaining({
+ where: expect.objectContaining({
+ partnerId: { in: [PARTNER_ID] },
+ status: "confirmed",
+ // Lifted program bans must not flag new applications
+ OR: [
+ { source: "admin" },
+ {
+ programEnrollment: {
+ status: ProgramEnrollmentStatus.banned,
+ },
+ },
+ ],
+ }),
+ }),
+ );
+ expect(createdEvents()).toEqual([
+ {
+ programId: PROGRAM_ID,
+ partnerId: PARTNER_ID,
+ type: FraudRuleType.partnerCrossProgramBan,
+ sourceProgramId: BANNING_PROGRAM_ID,
+ metadata: {
+ bannedReason: "tos_violation",
+ bannedAt: BANNED_AT,
+ },
+ },
+ ]);
+ });
+
+ it("flags an applicant with a confirmed admin ban", async () => {
+ mocks.fraudAlertFindMany.mockResolvedValue([adminBanAlert]);
+
+ await detectAndRecordFraudApplication({ context });
+
+ expect(createdEvents()).toEqual([
+ expect.objectContaining({
+ type: FraudRuleType.partnerCrossProgramBan,
+ sourceProgramId: NETWORK_PROGRAM_ID,
+ metadata: {
+ bannedReason: "fraud",
+ bannedAt: REVIEWED_AT,
+ },
+ }),
+ ]);
+ });
+
+ it("flags an admin ban stored on the applying program", async () => {
+ mocks.fraudAlertFindMany.mockResolvedValue([
+ { ...adminBanAlert, programId: PROGRAM_ID },
+ ]);
+
+ await detectAndRecordFraudApplication({ context });
+
+ expect(createdEvents()).toEqual([
+ expect.objectContaining({
+ sourceProgramId: NETWORK_PROGRAM_ID,
+ }),
+ ]);
+ });
+
+ it("does not flag a program ban from the applying program", async () => {
+ mocks.fraudAlertFindMany.mockResolvedValue([
+ { ...programBanAlert, programId: PROGRAM_ID },
+ ]);
+
+ await detectAndRecordFraudApplication({ context });
+
+ expect(createdEvents()).toEqual([]);
+ });
+
+ it("does not flag an applicant without a confirmed ban", async () => {
+ await detectAndRecordFraudApplication({ context });
+
+ expect(createdEvents()).toEqual([]);
+ });
+
+ it("does not check bans when the rule is disabled", async () => {
+ mocks.fraudRuleFindMany.mockResolvedValue([
+ {
+ programId: PROGRAM_ID,
+ type: FraudRuleType.partnerCrossProgramBan,
+ disabledAt: new Date(),
+ config: null,
+ },
+ ]);
+ mocks.fraudAlertFindMany.mockResolvedValue([programBanAlert]);
+
+ await detectAndRecordFraudApplication({ context });
+
+ expect(mocks.fraudAlertFindMany).not.toHaveBeenCalled();
+ expect(createdEvents()).toEqual([]);
+ });
+});
diff --git a/apps/web/tests/partners/complete-program-applications.test.ts b/apps/web/tests/partners/complete-program-applications.test.ts
index 5cce31b168..5f2ae9a785 100644
--- a/apps/web/tests/partners/complete-program-applications.test.ts
+++ b/apps/web/tests/partners/complete-program-applications.test.ts
@@ -33,7 +33,7 @@ vi.mock("@/lib/prisma", () => ({
// Side effects of a completed application are not under test here
vi.mock("@/lib/api/fraud/detect-record-fraud-application", () => ({
- detectAndRecordFraudApplication: vi.fn(),
+ detectAndRecordFraudApplication: vi.fn().mockResolvedValue(undefined),
}));
vi.mock("@/lib/api/partners/notify-program-application", () => ({