diff --git a/contracts/Cargo.toml b/contracts/Cargo.toml
index 4e14fb1..94c17e6 100644
--- a/contracts/Cargo.toml
+++ b/contracts/Cargo.toml
@@ -4,7 +4,7 @@ members = [
     "proxy",
     "storage",
     "subscription",
-    "invoice",
+    "fraud",
     "types",
 ]
 
@@ -16,4 +16,8 @@ strip = "symbols"
 debug-assertions = false
 panic = "abort"
 codegen-units = 1
-lto = true
\ No newline at end of file
+lto = true
+
+[workspace.dependencies]
+soroban-sdk = "21.0.0"
+arbitrary = { version = "1.3", features = ["derive"] }
diff --git a/contracts/fraud/Cargo.toml b/contracts/fraud/Cargo.toml
new file mode 100644
index 0000000..c97eb08
--- /dev/null
+++ b/contracts/fraud/Cargo.toml
@@ -0,0 +1,16 @@
+[package]
+name = "subtrackr-fraud"
+version = "0.2.0"
+edition = "2021"
+authors = ["SubTrackr Team"]
+description = "SubTrackr fraud detection contract (Soroban)"
+
+[lib]
+crate-type = ["cdylib", "rlib"]
+
+[dependencies]
+soroban-sdk = "21.0.0"
+subtrackr-types = { path = "../types" }
+
+[dev-dependencies]
+soroban-sdk = { version = "21.0.0", features = ["testutils"] }
diff --git a/contracts/fraud/src/lib.rs b/contracts/fraud/src/lib.rs
new file mode 100644
index 0000000..125c689
--- /dev/null
+++ b/contracts/fraud/src/lib.rs
@@ -0,0 +1,486 @@
+#![no_std]
+
+use soroban_sdk::{contract, contractimpl, contracttype, Address, Env, String, Vec};
+use subtrackr_types::{
+    FraudAction, FraudCase, FraudReport, FraudReviewStatus, MerchantId, RiskScore, RiskSignal,
+    RiskSignalKind, SubscriptionId,
+};
+
+const HIGH_RISK_THRESHOLD: u32 = 80;
+const REVIEW_THRESHOLD: u32 = 50;
+const VELOCITY_WINDOW_SECS: u64 = 86_400;
+const VELOCITY_LIMIT: u32 = 3;
+const MAX_REVIEW_CASES: u32 = 5;
+
+#[contracttype]
+#[derive(Clone, Debug, PartialEq)]
+struct SubscriptionProfile {
+    subscription_id: SubscriptionId,
+    subscriber: Address,
+    merchant_id: MerchantId,
+    created_at: u64,
+    last_activity_at: u64,
+    expected_usage: u32,
+    observed_usage: u32,
+    chargebacks: u32,
+    is_flagged: bool,
+    is_blocked: bool,
+}
+
+#[contracttype]
+#[derive(Clone, Debug, PartialEq)]
+enum StorageKey {
+    Subscription(SubscriptionId),
+    SubscriberSubscriptions(Address),
+    MerchantSubscriptions(Address),
+    ReviewCase(SubscriptionId),
+}
+
+fn push_unique_u64(items: &mut Vec<SubscriptionId>, value: SubscriptionId) {
+    let mut i = 0u32;
+    while i < items.len() {
+        if items.get(i).unwrap() == value {
+            return;
+        }
+        i += 1;
+    }
+    items.push_back(value);
+}
+
+fn push_unique_address(items: &mut Vec<Address>, value: Address) {
+    let mut i = 0u32;
+    while i < items.len() {
+        if items.get(i).unwrap() == value {
+            return;
+        }
+        i += 1;
+    }
+    items.push_back(value);
+}
+
+fn get_subscriptions(env: &Env, subscriber: &Address) -> Vec<SubscriptionId> {
+    env.storage()
+        .persistent()
+        .get::<_, Vec<SubscriptionId>>(&StorageKey::SubscriberSubscriptions(subscriber.clone()))
+        .unwrap_or_else(|| Vec::new(env))
+}
+
+fn get_merchant_subscriptions(env: &Env, merchant: &Address) -> Vec<SubscriptionId> {
+    env.storage()
+        .persistent()
+        .get::<_, Vec<SubscriptionId>>(&StorageKey::MerchantSubscriptions(merchant.clone()))
+        .unwrap_or_else(|| Vec::new(env))
+}
+
+fn save_subscriptions(env: &Env, subscriber: &Address, ids: &Vec<SubscriptionId>) {
+    env.storage()
+        .persistent()
+        .set(&StorageKey::SubscriberSubscriptions(subscriber.clone()), &ids.clone());
+}
+
+fn save_merchant_subscriptions(env: &Env, merchant: &Address, ids: &Vec<SubscriptionId>) {
+    env.storage()
+        .persistent()
+        .set(&StorageKey::MerchantSubscriptions(merchant.clone()), &ids.clone());
+}
+
+fn load_profile(env: &Env, subscription_id: SubscriptionId) -> Option<SubscriptionProfile> {
+    env.storage()
+        .persistent()
+        .get(&StorageKey::Subscription(subscription_id))
+}
+
+fn save_profile(env: &Env, profile: &SubscriptionProfile) {
+    env.storage()
+        .persistent()
+        .set(&StorageKey::Subscription(profile.subscription_id), &profile.clone());
+}
+
+fn determine_velocity_score(env: &Env, profile: &SubscriptionProfile, ids: &Vec<SubscriptionId>) -> u32 {
+    let now = env.ledger().timestamp();
+    let mut recent_creations = 0u32;
+    let mut i = 0u32;
+    while i < ids.len() {
+        if let Some(sub_id) = ids.get(i) {
+            if let Some(other) = load_profile(env, sub_id) {
+                if now.saturating_sub(other.created_at) <= VELOCITY_WINDOW_SECS
+                    && other.subscriber == profile.subscriber
+                {
+                    recent_creations += 1;
+                }
+            }
+        }
+        i += 1;
+    }
+
+    if recent_creations <= VELOCITY_LIMIT {
+        0
+    } else {
+        ((recent_creations - VELOCITY_LIMIT) * 15).min(40)
+    }
+}
+
+fn determine_anomaly_score(profile: &SubscriptionProfile) -> u32 {
+    if profile.expected_usage == 0 && profile.observed_usage > 0 {
+        return 20;
+    }
+
+    if profile.expected_usage == 0 {
+        return 0;
+    }
+
+    if profile.observed_usage >= profile.expected_usage.saturating_mul(3) {
+        35
+    } else if profile.observed_usage >= profile.expected_usage.saturating_mul(2) {
+        25
+    } else if profile.observed_usage > profile.expected_usage {
+        10
+    } else {
+        0
+    }
+}
+
+fn determine_chargeback_score(profile: &SubscriptionProfile) -> u32 {
+    match profile.chargebacks {
+        0 => 0,
+        1 => 30,
+        2 => 50,
+        _ => 70,
+    }
+}
+
+fn determine_action(score: u32) -> FraudAction {
+    if score >= HIGH_RISK_THRESHOLD {
+        FraudAction::Block
+    } else if score >= REVIEW_THRESHOLD {
+        FraudAction::Flag
+    } else {
+        FraudAction::Approve
+    }
+}
+
+fn score_profile(
+    env: &Env,
+    profile: &SubscriptionProfile,
+    ids: &Vec<SubscriptionId>,
+) -> RiskScore {
+    let now = env.ledger().timestamp();
+    let velocity_score = determine_velocity_score(env, profile, ids);
+    let anomaly_score = determine_anomaly_score(profile);
+    let chargeback_score = determine_chargeback_score(profile);
+    let total_score = (velocity_score + anomaly_score + chargeback_score).min(100);
+
+    let mut signals = Vec::new(env);
+    if velocity_score > 0 {
+        signals.push_back(RiskSignal {
+            kind: RiskSignalKind::Velocity,
+            score: velocity_score,
+            detail: String::from_str(env, "rapid subscription creation"),
+            observed_at: now,
+        });
+    }
+    if anomaly_score > 0 {
+        signals.push_back(RiskSignal {
+            kind: RiskSignalKind::UsageAnomaly,
+            score: anomaly_score,
+            detail: String::from_str(env, "usage pattern deviates from baseline"),
+            observed_at: now,
+        });
+    }
+    if chargeback_score > 0 {
+        signals.push_back(RiskSignal {
+            kind: RiskSignalKind::Chargeback,
+            score: chargeback_score,
+            detail: String::from_str(env, "chargeback history predicts dispute risk"),
+            observed_at: now,
+        });
+    }
+
+    let reason = if chargeback_score >= anomaly_score && chargeback_score >= velocity_score {
+        String::from_str(env, "chargeback risk dominates")
+    } else if velocity_score >= anomaly_score {
+        String::from_str(env, "velocity risk is elevated")
+    } else {
+        String::from_str(env, "usage anomaly detected")
+    };
+
+    RiskScore {
+        subscriber: profile.subscriber.clone(),
+        subscription_id: profile.subscription_id,
+        merchant_id: profile.merchant_id.clone(),
+        total_score,
+        velocity_score,
+        anomaly_score,
+        chargeback_score,
+        action: determine_action(total_score),
+        reason,
+        assessed_at: now,
+        signals,
+    }
+}
+
+fn persist_case(env: &Env, score: &RiskScore, status: FraudReviewStatus) -> FraudCase {
+    let case = FraudCase {
+        case_id: score.subscription_id,
+        subscription_id: score.subscription_id,
+        subscriber: score.subscriber.clone(),
+        merchant_id: score.merchant_id.clone(),
+        risk_score: score.total_score,
+        action: score.action.clone(),
+        status,
+        reason: score.reason.clone(),
+        created_at: score.assessed_at,
+        updated_at: score.assessed_at,
+    };
+
+    env.storage()
+        .persistent()
+        .set(&StorageKey::ReviewCase(score.subscription_id), &case.clone());
+    case
+}
+
+fn update_profile_action(env: &Env, subscription_id: SubscriptionId, score: &RiskScore) {
+    if let Some(mut profile) = load_profile(env, subscription_id) {
+        profile.is_flagged = matches!(score.action, FraudAction::Flag | FraudAction::Block);
+        profile.is_blocked = matches!(score.action, FraudAction::Block);
+        profile.last_activity_at = score.assessed_at;
+        save_profile(env, &profile);
+    }
+}
+
+fn review_case_for_subscription(env: &Env, subscription_id: SubscriptionId) -> Option<FraudCase> {
+    env.storage()
+        .persistent()
+        .get(&StorageKey::ReviewCase(subscription_id))
+}
+
+#[contract]
+pub struct SubTrackrFraud;
+
+#[contractimpl]
+impl SubTrackrFraud {
+    pub fn register_subscription(
+        env: Env,
+        subscriber: Address,
+        merchant_id: Address,
+        subscription_id: SubscriptionId,
+        created_at: u64,
+    ) {
+        subscriber.require_auth();
+
+        let profile = SubscriptionProfile {
+            subscription_id,
+            subscriber: subscriber.clone(),
+            merchant_id: merchant_id.clone(),
+            created_at,
+            last_activity_at: created_at,
+            expected_usage: 1,
+            observed_usage: 1,
+            chargebacks: 0,
+            is_flagged: false,
+            is_blocked: false,
+        };
+
+        save_profile(&env, &profile);
+
+        let mut subscriber_ids = get_subscriptions(&env, &subscriber);
+        push_unique_u64(&mut subscriber_ids, subscription_id);
+        save_subscriptions(&env, &subscriber, &subscriber_ids);
+
+        let mut merchant_ids = get_merchant_subscriptions(&env, &merchant_id);
+        push_unique_u64(&mut merchant_ids, subscription_id);
+        save_merchant_subscriptions(&env, &merchant_id, &merchant_ids);
+    }
+
+    pub fn record_usage_pattern(
+        env: Env,
+        subscriber: Address,
+        subscription_id: SubscriptionId,
+        expected_usage: u32,
+        observed_usage: u32,
+    ) {
+        subscriber.require_auth();
+
+        if let Some(mut profile) = load_profile(&env, subscription_id) {
+            profile.expected_usage = expected_usage;
+            profile.observed_usage = observed_usage;
+            profile.last_activity_at = env.ledger().timestamp();
+            save_profile(&env, &profile);
+        }
+    }
+
+    pub fn record_chargeback(
+        env: Env,
+        subscriber: Address,
+        subscription_id: SubscriptionId,
+    ) {
+        subscriber.require_auth();
+
+        if let Some(mut profile) = load_profile(&env, subscription_id) {
+            profile.chargebacks = profile.chargebacks.saturating_add(1);
+            profile.last_activity_at = env.ledger().timestamp();
+            save_profile(&env, &profile);
+        }
+    }
+
+    pub fn assess_risk(env: Env, subscriber: Address) -> RiskScore {
+        let ids = get_subscriptions(&env, &subscriber);
+        if ids.len() == 0 {
+            return RiskScore {
+                subscriber: subscriber.clone(),
+                subscription_id: 0,
+                merchant_id: subscriber.clone(),
+                total_score: 0,
+                velocity_score: 0,
+                anomaly_score: 0,
+                chargeback_score: 0,
+                action: FraudAction::Approve,
+                reason: String::from_str(&env, "no subscription history"),
+                assessed_at: env.ledger().timestamp(),
+                signals: Vec::new(&env),
+            };
+        }
+
+        let mut highest = score_profile(
+            &env,
+            &load_profile(&env, ids.get(0).unwrap()).unwrap(),
+            &ids,
+        );
+
+        let mut i = 1u32;
+        while i < ids.len() {
+            if let Some(profile) = load_profile(&env, ids.get(i).unwrap()) {
+                let next = score_profile(&env, &profile, &ids);
+                if next.total_score > highest.total_score {
+                    highest = next;
+                }
+            }
+            i += 1;
+        }
+
+        highest
+    }
+
+    pub fn flag_subscription(env: Env, subscription_id: SubscriptionId) {
+        if let Some(profile) = load_profile(&env, subscription_id) {
+            let ids = get_subscriptions(&env, &profile.subscriber);
+            let score = score_profile(&env, &profile, &ids);
+            let status = if matches!(score.action, FraudAction::Block) {
+                FraudReviewStatus::Escalated
+            } else {
+                FraudReviewStatus::Pending
+            };
+            let case = persist_case(&env, &score, status);
+            update_profile_action(&env, subscription_id, &score);
+            env.events().publish(
+                (String::from_str(&env, "fraud_case_opened"), score.subscription_id),
+                (case.risk_score, case.action.clone()),
+            );
+        } else {
+            panic!("Subscription not found");
+        }
+    }
+
+    pub fn resolve_case(
+        env: Env,
+        subscriber: Address,
+        subscription_id: SubscriptionId,
+        approved: bool,
+    ) {
+        subscriber.require_auth();
+        if let Some(mut case) = review_case_for_subscription(&env, subscription_id) {
+            case.status = FraudReviewStatus::Reviewed;
+            case.updated_at = env.ledger().timestamp();
+            case.action = if approved {
+                FraudAction::Approve
+            } else {
+                FraudAction::Block
+            };
+            env.storage()
+                .persistent()
+                .set(&StorageKey::ReviewCase(subscription_id), &case.clone());
+        }
+    }
+
+    pub fn get_fraud_report(env: Env, merchant_id: Address) -> FraudReport {
+        let ids = get_merchant_subscriptions(&env, &merchant_id);
+        let mut total_risk = 0u32;
+        let mut flagged = 0u32;
+        let mut blocked = 0u32;
+        let mut manual_review = 0u32;
+        let mut velocity_alerts = 0u32;
+        let mut anomaly_alerts = 0u32;
+        let mut chargeback_predictions = 0u32;
+        let mut high_risk_subscribers: Vec<Address> = Vec::new(&env);
+        let mut recent_cases: Vec<FraudCase> = Vec::new(&env);
+
+        let mut i = 0u32;
+        while i < ids.len() {
+            if let Some(profile) = load_profile(&env, ids.get(i).unwrap()) {
+                let subscriber_ids = get_subscriptions(&env, &profile.subscriber);
+                let score = score_profile(&env, &profile, &subscriber_ids);
+                total_risk += score.total_score;
+
+                if matches!(score.action, FraudAction::Flag | FraudAction::Block) {
+                    flagged += 1;
+                }
+                if matches!(score.action, FraudAction::Block) {
+                    blocked += 1;
+                }
+                if score.total_score >= REVIEW_THRESHOLD {
+                    manual_review += 1;
+                }
+                if score.velocity_score > 0 {
+                    velocity_alerts += 1;
+                }
+                if score.anomaly_score > 0 {
+                    anomaly_alerts += 1;
+                }
+                if score.chargeback_score > 0 {
+                    chargeback_predictions += 1;
+                }
+                if score.total_score >= REVIEW_THRESHOLD {
+                    push_unique_address(&mut high_risk_subscribers, score.subscriber.clone());
+                }
+
+                if let Some(case) = review_case_for_subscription(&env, score.subscription_id) {
+                    recent_cases.push_back(case);
+                } else if score.total_score >= REVIEW_THRESHOLD {
+                    recent_cases.push_back(persist_case(&env, &score, FraudReviewStatus::Pending));
+                }
+            }
+            i += 1;
+        }
+
+        let average_risk = if ids.len() == 0 {
+            0
+        } else {
+            total_risk / ids.len()
+        };
+
+        let mut trimmed_cases = Vec::new(&env);
+        let mut idx = recent_cases.len();
+        let mut copied = 0u32;
+        while idx > 0 && copied < MAX_REVIEW_CASES {
+            idx -= 1;
+            if let Some(case) = recent_cases.get(idx) {
+                trimmed_cases.push_back(case);
+                copied += 1;
+            }
+        }
+
+        FraudReport {
+            merchant_id,
+            total_subscriptions: ids.len(),
+            flagged_subscriptions: flagged,
+            blocked_subscriptions: blocked,
+            manual_review_count: manual_review,
+            average_risk,
+            velocity_alerts,
+            anomaly_alerts,
+            chargeback_predictions,
+            high_risk_subscribers: high_risk_subscribers.len(),
+            recent_cases: trimmed_cases,
+        }
+    }
+}
diff --git a/contracts/types/src/lib.rs b/contracts/types/src/lib.rs
index a5b4447..86daa83 100644
--- a/contracts/types/src/lib.rs
+++ b/contracts/types/src/lib.rs
@@ -201,125 +201,90 @@ pub struct UpgradeEvent {
     pub executed_at: Timestamp,
 }
 
+pub type SubscriptionId = u64;
+pub type MerchantId = Address;
+
 #[contracttype]
 #[derive(Clone, Debug, PartialEq)]
-pub enum WebhookEventType {
-    SubscriptionCreated,
-    SubscriptionUpdated,
-    SubscriptionCancelled,
-    SubscriptionPaused,
-    SubscriptionResumed,
-    SubscriptionCharged,
-    RefundRequested,
-    RefundApproved,
-    RefundRejected,
-    TransferRequested,
-    TransferAccepted,
+pub enum FraudAction {
+    Approve,
+    Flag,
+    Block,
 }
 
 #[contracttype]
 #[derive(Clone, Debug, PartialEq)]
-pub enum WebhookDeliveryStatus {
+pub enum FraudReviewStatus {
     Pending,
-    Retrying,
-    Delivered,
-    Failed,
-    Paused,
-    Skipped,
+    Reviewed,
+    Dismissed,
+    Escalated,
 }
 
 #[contracttype]
 #[derive(Clone, Debug, PartialEq)]
-pub struct WebhookRetryPolicy {
-    pub max_retries: u32,
-    pub initial_delay_secs: u64,
-    pub max_delay_secs: u64,
-    pub backoff_factor: u32,
+pub enum RiskSignalKind {
+    Velocity,
+    UsageAnomaly,
+    Chargeback,
+    PatternShift,
+    DeviceMismatch,
 }
 
 #[contracttype]
 #[derive(Clone, Debug, PartialEq)]
-pub struct WebhookSubscriptionSnapshot {
-    pub id: u64,
-    pub plan_id: u64,
-    pub subscriber: Address,
-    pub status: SubscriptionStatus,
-    pub started_at: u64,
-    pub last_charged_at: u64,
-    pub next_charge_at: u64,
-    pub total_paid: i128,
-    pub total_gas_spent: u64,
-    pub charge_count: u32,
-    pub paused_at: u64,
-    pub pause_duration: u64,
-    pub refund_requested_amount: i128,
+pub struct RiskSignal {
+    pub kind: RiskSignalKind,
+    pub score: u32,
+    pub detail: String,
+    pub observed_at: Timestamp,
 }
 
 #[contracttype]
 #[derive(Clone, Debug, PartialEq)]
-pub struct WebhookPlanSnapshot {
-    pub id: u64,
-    pub merchant: Address,
-    pub name: String,
-    pub price: i128,
-    pub token: Address,
-    pub interval: Interval,
-    pub active: bool,
-    pub subscriber_count: u32,
-    pub created_at: u64,
-}
-
-#[contracttype]
-#[derive(Clone, Debug, PartialEq)]
-pub struct WebhookConfig {
-    pub id: u64,
-    pub merchant: Address,
-    pub url: String,
-    pub events: Vec<WebhookEventType>,
-    pub secret_key: String,
-    pub retry_policy: WebhookRetryPolicy,
-    pub is_paused: bool,
-    pub created_at: u64,
-    pub updated_at: u64,
-    pub health_check_at: u64,
-    pub healthy: bool,
-    pub success_count: u64,
-    pub failure_count: u64,
+pub struct RiskScore {
+    pub subscriber: Address,
+    pub subscription_id: SubscriptionId,
+    pub merchant_id: MerchantId,
+    pub total_score: u32,
+    pub velocity_score: u32,
+    pub anomaly_score: u32,
+    pub chargeback_score: u32,
+    pub action: FraudAction,
+    pub reason: String,
+    pub assessed_at: Timestamp,
+    pub signals: Vec<RiskSignal>,
 }
 
 #[contracttype]
 #[derive(Clone, Debug, PartialEq)]
-pub struct WebhookEventPayload {
-    pub id: u64,
-    pub webhook_id: u64,
-    pub event_type: WebhookEventType,
-    pub merchant: Address,
-    pub occurred_at: u64,
-    pub subscription: WebhookSubscriptionSnapshot,
-    pub plan: WebhookPlanSnapshot,
-    pub previous_status: SubscriptionStatus,
-    pub current_status: SubscriptionStatus,
+pub struct FraudCase {
+    pub case_id: u64,
+    pub subscription_id: SubscriptionId,
+    pub subscriber: Address,
+    pub merchant_id: MerchantId,
+    pub risk_score: u32,
+    pub action: FraudAction,
+    pub status: FraudReviewStatus,
+    pub reason: String,
+    pub created_at: Timestamp,
+    pub updated_at: Timestamp,
 }
 
 #[contracttype]
 #[derive(Clone, Debug, PartialEq)]
-pub struct WebhookDelivery {
-    pub id: u64,
-    pub webhook_id: u64,
-    pub event_id: u64,
-    pub event_type: WebhookEventType,
-    pub payload: WebhookEventPayload,
-    pub status: WebhookDeliveryStatus,
-    pub attempts: u32,
-    pub max_attempts: u32,
-    pub next_retry_at: u64,
-    pub last_attempt_at: u64,
-    pub delivered_at: u64,
-    pub response_code: i32,
-    pub error_message: String,
-    pub signature: String,
-    pub created_at: u64,
-    pub updated_at: u64,
+pub struct FraudReport {
+    pub merchant_id: MerchantId,
+    pub total_subscriptions: u32,
+    pub flagged_subscriptions: u32,
+    pub blocked_subscriptions: u32,
+    pub manual_review_count: u32,
+    pub average_risk: u32,
+    pub velocity_alerts: u32,
+    pub anomaly_alerts: u32,
+    pub chargeback_predictions: u32,
+    pub high_risk_subscribers: u32,
+    pub recent_cases: Vec<FraudCase>,
 }
 
 /// Storage keys for the proxy contract state.
diff --git a/src/navigation/AppNavigator.tsx b/src/navigation/AppNavigator.tsx
index 38713fb..d136ef0 100644
--- a/src/navigation/AppNavigator.tsx
+++ b/src/navigation/AppNavigator.tsx
@@ -26,8 +26,7 @@ import ErrorDashboardScreen from '../screens/ErrorDashboardScreen';
 import ImportScreen from '../screens/ImportScreen';
 import ExportScreen from '../screens/ExportScreen';
 import AdminDashboardScreen from '../screens/AdminDashboardScreen';
-import InvoiceListScreen from '../screens/InvoiceListScreen';
-import InvoiceDetailScreen from '../screens/InvoiceDetailScreen';
+import FraudDashboard from '../screens/FraudDashboard';
 import { SegmentManagementScreen } from '../screens/SegmentManagementScreen';
 import { SegmentDetailScreen } from '../screens/SegmentDetailScreen';
 import { GamificationScreen } from '../screens/GamificationScreen';
@@ -178,35 +177,10 @@ const SettingsStack = () => (
       component={ErrorDashboardScreen}
       options={{ title: 'Error Dashboard', headerShown: true }}
     />
-    <Stack.Screen 
-      name="Import" 
-      component={ImportScreen} 
-      options={{ title: 'Import Subscriptions', headerShown: true }} 
-    />
-    <Stack.Screen 
-      name="Export" 
-      component={ExportScreen} 
-      options={{ title: 'Export Subscriptions', headerShown: true }} 
-    />
-    <Stack.Screen
-      name="MerchantOnboarding"
-      component={MerchantOnboardingScreen}
-      options={{ title: 'Merchant Onboarding', headerShown: true }}
-    />
-    <Stack.Screen
-      name="AffiliateDashboard"
-      component={AffiliateDashboardScreen}
-      options={{ title: 'Affiliate Dashboard', headerShown: true }}
-    />
-    <Stack.Screen
-      name="LoyaltyDashboard"
-      component={LoyaltyDashboardScreen}
-      options={{ title: 'Loyalty Dashboard', headerShown: true }}
-    />
     <Stack.Screen
-      name="CampaignManagement"
-      component={CampaignManagementScreen}
-      options={{ title: 'Campaign Management', headerShown: true }}
+      name="FraudDashboard"
+      component={FraudDashboard}
+      options={{ title: 'Fraud Dashboard', headerShown: true }}
     />
   </Stack.Navigator>
 );
diff --git a/src/navigation/types.ts b/src/navigation/types.ts
index f144e67..ea356c5 100644
--- a/src/navigation/types.ts
+++ b/src/navigation/types.ts
@@ -27,12 +27,7 @@ export type RootStackParamList = {
   SegmentManagement: undefined;
   SegmentDetail: { segmentId: string };
   Gamification: undefined;
-  RevenueReport: undefined;
-  UsageDashboard: { subscriptionId: string; planId: string; name: string };
-  MerchantOnboarding: undefined;
-  AffiliateDashboard: undefined;
-  LoyaltyDashboard: undefined;
-  CampaignManagement: undefined;
+  FraudDashboard: undefined;
 };
 
 export type TabParamList = {
diff --git a/src/screens/FraudDashboard.tsx b/src/screens/FraudDashboard.tsx
new file mode 100644
index 0000000..f26dd4b
--- /dev/null
+++ b/src/screens/FraudDashboard.tsx
@@ -0,0 +1,540 @@
+import React, { useMemo } from 'react';
+import {
+  SafeAreaView,
+  ScrollView,
+  StyleSheet,
+  Text,
+  TouchableOpacity,
+  View,
+  useWindowDimensions,
+} from 'react-native';
+import { Card } from '../components/common/Card';
+import { Button } from '../components/common/Button';
+import { colors, spacing, typography, borderRadius } from '../utils/constants';
+import { useFraudStore } from '../store/fraudStore';
+import { FraudAction } from '../types/fraud';
+
+const actionPalette: Record<FraudAction, string> = {
+  approve: colors.success,
+  flag: colors.warning,
+  block: colors.error,
+};
+
+const FraudDashboard: React.FC = () => {
+  const { width } = useWindowDimensions();
+  const isWide = width >= 980;
+  const {
+    merchants,
+    subscriptions,
+    assessments,
+    reviewQueue,
+    analytics,
+    refreshFraudSignals,
+    assessRisk,
+    approveSubscription,
+    blockSubscription,
+    resolveCase,
+    getFraudReport,
+  } = useFraudStore();
+
+  const highlightedReports = useMemo(
+    () => merchants.map((merchant) => getFraudReport(merchant.id)),
+    [merchants, getFraudReport]
+  );
+
+  const topRiskSubscriptions = useMemo(
+    () => [...subscriptions].sort((a, b) => b.riskScore - a.riskScore).slice(0, 5),
+    [subscriptions]
+  );
+
+  const renderMetric = (label: string, value: string, hint: string, color: string) => (
+    <Card style={styles.metricCard}>
+      <View style={[styles.metricAccent, { backgroundColor: color }]} />
+      <Text style={styles.metricValue}>{value}</Text>
+      <Text style={styles.metricLabel}>{label}</Text>
+      <Text style={styles.metricHint}>{hint}</Text>
+    </Card>
+  );
+
+  return (
+    <SafeAreaView style={styles.container}>
+      <ScrollView contentContainerStyle={styles.content}>
+        <View style={[styles.hero, isWide && styles.heroWide]}>
+          <View style={styles.heroCopy}>
+            <Text style={styles.title}>Fraud Control Center</Text>
+            <Text style={styles.subtitle}>
+              Risk scoring, velocity checks, usage anomaly detection, chargeback prediction, and a
+              manual review queue for subscription operations.
+            </Text>
+          </View>
+          <View style={styles.heroActions}>
+            <Button title="Recalculate risk" onPress={refreshFraudSignals} size="small" />
+          </View>
+        </View>
+
+        <View style={[styles.metricsGrid, isWide && styles.metricsGridWide]}>
+          {renderMetric('Total checks', analytics.totalChecks.toString(), 'Subscriptions reviewed', colors.accent)}
+          {renderMetric('Blocked', analytics.blocked.toString(), 'Automated hard stops', colors.error)}
+          {renderMetric('Flagged', analytics.flagged.toString(), 'Queued for review', colors.warning)}
+          {renderMetric('Avg risk', `${analytics.avgRisk}`, 'Aggregate risk score', colors.primary)}
+        </View>
+
+        <View style={[styles.metricsGrid, isWide && styles.metricsGridWide]}>
+          {renderMetric('Velocity alerts', analytics.velocityAlerts.toString(), 'Rapid creation detected', colors.secondary)}
+          {renderMetric('Anomaly alerts', analytics.anomalyAlerts.toString(), 'Usage deviates from baseline', colors.accent)}
+          {renderMetric(
+            'Chargeback predictions',
+            analytics.chargebackPredictions.toString(),
+            'Predicted dispute exposure',
+            colors.error
+          )}
+          {renderMetric(
+            'False positives',
+            analytics.falsePositiveEstimate.toString(),
+            'Estimated manual override rate',
+            colors.success
+          )}
+        </View>
+
+        <View style={[styles.grid, isWide && styles.gridWide]}>
+          <Card style={[styles.sectionCard, isWide && styles.halfCard]}>
+            <View style={styles.sectionHeader}>
+              <Text style={styles.sectionTitle}>Manual review queue</Text>
+              <Text style={styles.sectionMeta}>{reviewQueue.length} open cases</Text>
+            </View>
+            {reviewQueue.map((item) => (
+              <View key={item.caseId} style={styles.caseRow}>
+                <View style={styles.caseCopy}>
+                  <Text style={styles.caseTitle}>{item.subscriptionName}</Text>
+                  <Text style={styles.caseDescription}>
+                    {item.merchantName} · {item.reason}
+                  </Text>
+                  <View style={styles.badgeRow}>
+                    <View style={[styles.badge, { borderColor: actionPalette[item.action] }]}>
+                      <Text style={[styles.badgeText, { color: actionPalette[item.action] }]}>
+                        {item.action}
+                      </Text>
+                    </View>
+                    <View style={styles.badgeMuted}>
+                      <Text style={styles.badgeMutedText}>Risk {item.riskScore}</Text>
+                    </View>
+                  </View>
+                </View>
+                <View style={styles.caseActions}>
+                  <TouchableOpacity style={styles.caseButton} onPress={() => approveSubscription(item.subscriptionId)}>
+                    <Text style={styles.caseButtonText}>Approve</Text>
+                  </TouchableOpacity>
+                  <TouchableOpacity style={styles.caseButtonWarning} onPress={() => resolveCase(item.subscriptionId, 'flag')}>
+                    <Text style={styles.caseButtonText}>Flag</Text>
+                  </TouchableOpacity>
+                  <TouchableOpacity style={styles.caseButtonDanger} onPress={() => blockSubscription(item.subscriptionId)}>
+                    <Text style={styles.caseButtonText}>Block</Text>
+                  </TouchableOpacity>
+                </View>
+              </View>
+            ))}
+            {reviewQueue.length === 0 ? <Text style={styles.emptyText}>No cases awaiting manual review.</Text> : null}
+          </Card>
+
+          <Card style={[styles.sectionCard, isWide && styles.halfCard]}>
+            <View style={styles.sectionHeader}>
+              <Text style={styles.sectionTitle}>Top risk subscriptions</Text>
+              <Text style={styles.sectionMeta}>Live risk signals</Text>
+            </View>
+            {topRiskSubscriptions.map((item) => (
+              <View key={item.id} style={styles.subscriptionRow}>
+                <View style={styles.caseCopy}>
+                  <Text style={styles.caseTitle}>{item.subscriptionName}</Text>
+                  <Text style={styles.caseDescription}>
+                    {item.merchantName} · {item.subscriberId} · {item.currency} {item.amount}
+                  </Text>
+                  <View style={styles.badgeRow}>
+                    <View style={[styles.badge, { borderColor: actionPalette[item.action] }]}>
+                      <Text style={[styles.badgeText, { color: actionPalette[item.action] }]}>
+                        {item.action}
+                      </Text>
+                    </View>
+                    <Text style={styles.scoreText}>{item.riskScore}</Text>
+                  </View>
+                </View>
+                <Button
+                  title="Assess"
+                  size="small"
+                  variant="secondary"
+                  onPress={() => {
+                    void assessRisk(item.subscriberId);
+                  }}
+                />
+              </View>
+            ))}
+          </Card>
+
+          <Card style={[styles.sectionCard, isWide && styles.halfCard]}>
+            <View style={styles.sectionHeader}>
+              <Text style={styles.sectionTitle}>Merchant analytics</Text>
+              <Text style={styles.sectionMeta}>Fraud reports by merchant</Text>
+            </View>
+            {highlightedReports.map((report) => (
+              <View key={report.merchantId} style={styles.reportRow}>
+                <View style={styles.reportHeader}>
+                  <Text style={styles.caseTitle}>{report.merchantName}</Text>
+                  <Text style={styles.scoreText}>{report.averageRisk}</Text>
+                </View>
+                <Text style={styles.caseDescription}>
+                  {report.totalSubscriptions} subs · {report.flaggedSubscriptions} flagged · {report.blockedSubscriptions} blocked
+                </Text>
+                <View style={styles.reportGrid}>
+                  <Text style={styles.reportMetric}>Manual review {report.manualReviewCount}</Text>
+                  <Text style={styles.reportMetric}>Velocity {report.velocityAlerts}</Text>
+                  <Text style={styles.reportMetric}>Anomaly {report.anomalyAlerts}</Text>
+                  <Text style={styles.reportMetric}>Chargeback {report.chargebackPredictions}</Text>
+                </View>
+              </View>
+            ))}
+          </Card>
+
+          <Card style={[styles.sectionCard, isWide && styles.halfCard]}>
+            <View style={styles.sectionHeader}>
+              <Text style={styles.sectionTitle}>Risk distribution</Text>
+              <Text style={styles.sectionMeta}>Action outcomes</Text>
+            </View>
+            <View style={styles.distributionRow}>
+              <Text style={styles.distributionLabel}>Approved</Text>
+              <View style={styles.distributionBarTrack}>
+                <View style={[styles.distributionBar, { width: `${(analytics.approved / Math.max(analytics.totalChecks, 1)) * 100}%`, backgroundColor: colors.success }]} />
+              </View>
+              <Text style={styles.distributionValue}>{analytics.approved}</Text>
+            </View>
+            <View style={styles.distributionRow}>
+              <Text style={styles.distributionLabel}>Flagged</Text>
+              <View style={styles.distributionBarTrack}>
+                <View style={[styles.distributionBar, { width: `${(analytics.flagged / Math.max(analytics.totalChecks, 1)) * 100}%`, backgroundColor: colors.warning }]} />
+              </View>
+              <Text style={styles.distributionValue}>{analytics.flagged}</Text>
+            </View>
+            <View style={styles.distributionRow}>
+              <Text style={styles.distributionLabel}>Blocked</Text>
+              <View style={styles.distributionBarTrack}>
+                <View style={[styles.distributionBar, { width: `${(analytics.blocked / Math.max(analytics.totalChecks, 1)) * 100}%`, backgroundColor: colors.error }]} />
+              </View>
+              <Text style={styles.distributionValue}>{analytics.blocked}</Text>
+            </View>
+          </Card>
+        </View>
+
+        <Card style={styles.sectionCard}>
+          <View style={styles.sectionHeader}>
+            <Text style={styles.sectionTitle}>Signal feed</Text>
+            <Text style={styles.sectionMeta}>Latest assessments</Text>
+          </View>
+          {assessments.slice(0, 6).map((item) => (
+            <View key={`${item.subscriptionId}-${item.assessedAt}`} style={styles.feedRow}>
+              <View style={styles.feedCopy}>
+                <Text style={styles.feedTitle}>{item.merchantName}</Text>
+                <Text style={styles.feedDescription}>{item.reason}</Text>
+                <View style={styles.badgeRow}>
+                  {item.signals.map((signal) => (
+                    <View key={`${signal.kind}-${signal.observedAt}`} style={styles.signalChip}>
+                      <Text style={styles.signalChipText}>
+                        {signal.kind} {signal.score}
+                      </Text>
+                    </View>
+                  ))}
+                </View>
+              </View>
+              <View style={[styles.actionPill, { backgroundColor: actionPalette[item.action] }]}>
+                <Text style={styles.actionPillText}>{item.action}</Text>
+              </View>
+            </View>
+          ))}
+        </Card>
+      </ScrollView>
+    </SafeAreaView>
+  );
+};
+
+const styles = StyleSheet.create({
+  container: {
+    flex: 1,
+    backgroundColor: colors.background,
+  },
+  content: {
+    padding: spacing.lg,
+    paddingBottom: spacing.xxl,
+    gap: spacing.lg,
+  },
+  hero: {
+    gap: spacing.md,
+  },
+  heroWide: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'flex-start',
+  },
+  heroCopy: {
+    flex: 1,
+    maxWidth: 760,
+  },
+  heroActions: {
+    alignItems: 'flex-end',
+  },
+  title: {
+    ...typography.h1,
+    color: colors.text,
+    marginBottom: spacing.xs,
+  },
+  subtitle: {
+    ...typography.body,
+    color: colors.textSecondary,
+  },
+  metricsGrid: {
+    gap: spacing.md,
+  },
+  metricsGridWide: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+  },
+  metricCard: {
+    flex: 1,
+    minWidth: 160,
+  },
+  metricAccent: {
+    width: 38,
+    height: 4,
+    borderRadius: borderRadius.full,
+    marginBottom: spacing.md,
+  },
+  metricValue: {
+    ...typography.h2,
+    color: colors.text,
+    marginBottom: spacing.xs,
+  },
+  metricLabel: {
+    ...typography.body,
+    color: colors.textSecondary,
+    fontWeight: '600',
+  },
+  metricHint: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    marginTop: spacing.xs,
+  },
+  grid: {
+    gap: spacing.md,
+  },
+  gridWide: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+  },
+  sectionCard: {
+    flexBasis: '100%',
+  },
+  halfCard: {
+    flexBasis: '48.5%',
+  },
+  sectionHeader: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'center',
+    marginBottom: spacing.md,
+    gap: spacing.sm,
+  },
+  sectionTitle: {
+    ...typography.h3,
+    color: colors.text,
+  },
+  sectionMeta: {
+    ...typography.caption,
+    color: colors.accent,
+  },
+  caseRow: {
+    flexDirection: 'row',
+    gap: spacing.md,
+    alignItems: 'flex-start',
+    paddingVertical: spacing.md,
+    borderBottomWidth: 1,
+    borderBottomColor: colors.border,
+  },
+  caseCopy: {
+    flex: 1,
+  },
+  caseTitle: {
+    ...typography.body,
+    color: colors.text,
+    fontWeight: '700',
+  },
+  caseDescription: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    marginTop: spacing.xs,
+  },
+  badgeRow: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+    gap: spacing.xs,
+    marginTop: spacing.sm,
+  },
+  badge: {
+    paddingVertical: 4,
+    paddingHorizontal: spacing.sm,
+    borderRadius: borderRadius.full,
+    borderWidth: 1,
+    backgroundColor: colors.surface,
+  },
+  badgeText: {
+    ...typography.caption,
+    fontWeight: '700',
+    textTransform: 'uppercase',
+  },
+  badgeMuted: {
+    paddingVertical: 4,
+    paddingHorizontal: spacing.sm,
+    borderRadius: borderRadius.full,
+    backgroundColor: 'rgba(255,255,255,0.06)',
+  },
+  badgeMutedText: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    fontWeight: '600',
+  },
+  caseActions: {
+    gap: spacing.xs,
+  },
+  caseButton: {
+    paddingVertical: spacing.sm,
+    paddingHorizontal: spacing.md,
+    borderRadius: borderRadius.md,
+    backgroundColor: colors.surface,
+    borderWidth: 1,
+    borderColor: colors.border,
+  },
+  caseButtonWarning: {
+    paddingVertical: spacing.sm,
+    paddingHorizontal: spacing.md,
+    borderRadius: borderRadius.md,
+    backgroundColor: colors.warning,
+  },
+  caseButtonDanger: {
+    paddingVertical: spacing.sm,
+    paddingHorizontal: spacing.md,
+    borderRadius: borderRadius.md,
+    backgroundColor: colors.error,
+  },
+  caseButtonText: {
+    ...typography.caption,
+    color: colors.text,
+    fontWeight: '700',
+  },
+  emptyText: {
+    ...typography.caption,
+    color: colors.textSecondary,
+  },
+  subscriptionRow: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    justifyContent: 'space-between',
+    gap: spacing.md,
+    paddingVertical: spacing.md,
+    borderBottomWidth: 1,
+    borderBottomColor: colors.border,
+  },
+  reportRow: {
+    paddingVertical: spacing.md,
+    borderBottomWidth: 1,
+    borderBottomColor: colors.border,
+  },
+  reportHeader: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    alignItems: 'center',
+  },
+  reportGrid: {
+    flexDirection: 'row',
+    flexWrap: 'wrap',
+    gap: spacing.sm,
+    marginTop: spacing.sm,
+  },
+  reportMetric: {
+    ...typography.caption,
+    color: colors.textSecondary,
+  },
+  scoreText: {
+    ...typography.h3,
+    color: colors.text,
+    fontWeight: '700',
+  },
+  distributionRow: {
+    flexDirection: 'row',
+    alignItems: 'center',
+    gap: spacing.sm,
+    marginBottom: spacing.md,
+  },
+  distributionLabel: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    width: 72,
+  },
+  distributionBarTrack: {
+    flex: 1,
+    height: 10,
+    borderRadius: borderRadius.full,
+    backgroundColor: colors.surface,
+    overflow: 'hidden',
+  },
+  distributionBar: {
+    height: '100%',
+    borderRadius: borderRadius.full,
+  },
+  distributionValue: {
+    ...typography.caption,
+    color: colors.text,
+    width: 32,
+    textAlign: 'right',
+  },
+  feedRow: {
+    flexDirection: 'row',
+    justifyContent: 'space-between',
+    gap: spacing.md,
+    paddingVertical: spacing.md,
+    borderBottomWidth: 1,
+    borderBottomColor: colors.border,
+  },
+  feedCopy: {
+    flex: 1,
+  },
+  feedTitle: {
+    ...typography.body,
+    color: colors.text,
+    fontWeight: '700',
+  },
+  feedDescription: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    marginTop: spacing.xs,
+  },
+  signalChip: {
+    paddingVertical: 4,
+    paddingHorizontal: spacing.sm,
+    borderRadius: borderRadius.full,
+    backgroundColor: colors.surface,
+  },
+  signalChipText: {
+    ...typography.caption,
+    color: colors.textSecondary,
+    fontWeight: '600',
+  },
+  actionPill: {
+    paddingVertical: spacing.sm,
+    paddingHorizontal: spacing.md,
+    borderRadius: borderRadius.full,
+    alignSelf: 'flex-start',
+  },
+  actionPillText: {
+    ...typography.caption,
+    color: colors.text,
+    fontWeight: '700',
+    textTransform: 'uppercase',
+  },
+});
+
+export default FraudDashboard;
diff --git a/src/screens/SettingsScreen.tsx b/src/screens/SettingsScreen.tsx
index a768b60..fdcbea5 100644
--- a/src/screens/SettingsScreen.tsx
+++ b/src/screens/SettingsScreen.tsx
@@ -326,6 +326,17 @@ const SettingsScreen: React.FC = () => {
               →
             </Text>
           </TouchableOpacity>
+          <TouchableOpacity
+            style={styles.linkRow}
+            onPress={() => navigation.navigate('FraudDashboard')}
+            accessibilityRole="button"
+            accessibilityLabel="Fraud dashboard"
+            accessibilityHint="Opens fraud monitoring and manual review controls">
+            <Text style={styles.linkText}>Fraud Dashboard</Text>
+            <Text style={styles.linkArrow} accessibilityElementsHidden={true}>
+              →
+            </Text>
+          </TouchableOpacity>
           <TouchableOpacity
             style={styles.linkRow}
             onPress={() => navigation.navigate('LanguageSettings')}
diff --git a/src/store/__tests__/fraudStore.test.ts b/src/store/__tests__/fraudStore.test.ts
new file mode 100644
index 0000000..54c3c98
--- /dev/null
+++ b/src/store/__tests__/fraudStore.test.ts
@@ -0,0 +1,141 @@
+import { act } from 'react';
+import { describe, it, expect, beforeEach, jest } from '@jest/globals';
+import { useFraudStore } from '../fraudStore';
+
+jest.mock('@react-native-async-storage/async-storage', () => ({
+  setItem: jest.fn(() => Promise.resolve()),
+  getItem: jest.fn(() => Promise.resolve(null)),
+  removeItem: jest.fn(() => Promise.resolve()),
+}));
+
+describe('fraudStore', () => {
+  beforeEach(() => {
+    useFraudStore.setState({
+      merchants: [],
+      subscriptions: [],
+      assessments: [],
+      reviewQueue: [],
+      analytics: {
+        totalChecks: 0,
+        approved: 0,
+        flagged: 0,
+        blocked: 0,
+        manualReviews: 0,
+        avgRisk: 0,
+        velocityAlerts: 0,
+        anomalyAlerts: 0,
+        chargebackPredictions: 0,
+        falsePositiveEstimate: 0,
+      },
+      loading: false,
+      error: null,
+    });
+  });
+
+  it('scores rapid creation and queues review cases', () => {
+    useFraudStore.setState({
+      merchants: [
+        {
+          id: 'm1',
+          name: 'FastPay',
+          status: 'watch',
+          activeSubscriptions: 2,
+          blockedSubscriptions: 0,
+          averageRisk: 30,
+          monthlyVolume: 5000,
+        },
+      ],
+      subscriptions: [
+        {
+          id: 's1',
+          merchantId: 'm1',
+          merchantName: 'FastPay',
+          subscriberId: 'sub-1',
+          subscriptionName: 'Plan A',
+          currency: 'USD',
+          amount: 10,
+          createdAt: '2026-04-24T07:00:00.000Z',
+          expectedUsage: 2,
+          observedUsage: 8,
+          chargebacks: 1,
+          riskScore: 81,
+          action: 'flag',
+          reason: 'high velocity',
+          usagePattern: 'burst',
+          signals: [],
+          isBlocked: false,
+          isFlagged: true,
+        },
+      ],
+    });
+
+    act(() => {
+      useFraudStore.getState().refreshFraudSignals();
+    });
+
+    const report = useFraudStore.getState().getFraudReport('m1');
+    expect(report.averageRisk).toBe(81);
+    expect(report.flaggedSubscriptions).toBe(1);
+  });
+
+  it('approves and blocks subscriptions through review actions', () => {
+    useFraudStore.setState({
+      merchants: [
+        {
+          id: 'm2',
+          name: 'ReviewCo',
+          status: 'high-risk',
+          activeSubscriptions: 1,
+          blockedSubscriptions: 1,
+          averageRisk: 92,
+          monthlyVolume: 9000,
+        },
+      ],
+      subscriptions: [
+        {
+          id: 's2',
+          merchantId: 'm2',
+          merchantName: 'ReviewCo',
+          subscriberId: 'sub-2',
+          subscriptionName: 'Plan B',
+          currency: 'USD',
+          amount: 100,
+          createdAt: '2026-04-24T08:00:00.000Z',
+          expectedUsage: 1,
+          observedUsage: 12,
+          chargebacks: 2,
+          riskScore: 92,
+          action: 'block',
+          reason: 'chargeback risk',
+          usagePattern: 'erratic',
+          signals: [],
+          isBlocked: true,
+          isFlagged: true,
+        },
+      ],
+      reviewQueue: [
+        {
+          caseId: 's2',
+          subscriptionId: 's2',
+          subscriberId: 'sub-2',
+          merchantId: 'm2',
+          merchantName: 'ReviewCo',
+          subscriptionName: 'Plan B',
+          riskScore: 92,
+          action: 'block',
+          status: 'escalated',
+          reason: 'chargeback risk',
+          createdAt: '2026-04-24T08:00:00.000Z',
+          updatedAt: '2026-04-24T08:00:00.000Z',
+        },
+      ],
+    });
+
+    act(() => {
+      useFraudStore.getState().approveSubscription('s2');
+    });
+
+    expect(useFraudStore.getState().subscriptions[0].action).toBe('approve');
+    expect(useFraudStore.getState().reviewQueue[0].status).toBe('reviewed');
+  });
+});
diff --git a/src/store/fraudStore.ts b/src/store/fraudStore.ts
new file mode 100644
index 0000000..a4f281a
--- /dev/null
+++ b/src/store/fraudStore.ts
@@ -0,0 +1,454 @@
+import { create } from 'zustand';
+import { persist, createJSONStorage } from 'zustand/middleware';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import {
+  FraudAction,
+  FraudAnalytics,
+  FraudCase,
+  FraudMerchantRecord,
+  FraudReport,
+  FraudRiskScore,
+  FraudSignal,
+  FraudSubscriptionRecord,
+} from '../types/fraud';
+
+const STORAGE_KEY = 'subtrackr-fraud-store';
+
+const nowIso = () => new Date().toISOString();
+
+const merchantSeeds: FraudMerchantRecord[] = [
+  {
+    id: 'merch_nova',
+    name: 'Nova Stream',
+    status: 'watch',
+    activeSubscriptions: 128,
+    blockedSubscriptions: 4,
+    averageRisk: 41,
+    monthlyVolume: 18650,
+  },
+  {
+    id: 'merch_orbit',
+    name: 'Orbit Tools',
+    status: 'healthy',
+    activeSubscriptions: 83,
+    blockedSubscriptions: 1,
+    averageRisk: 22,
+    monthlyVolume: 9420,
+  },
+  {
+    id: 'merch_cipher',
+    name: 'Cipher Pro',
+    status: 'high-risk',
+    activeSubscriptions: 46,
+    blockedSubscriptions: 9,
+    averageRisk: 67,
+    monthlyVolume: 7825,
+  },
+];
+
+const subscriptionSeeds: FraudSubscriptionRecord[] = [
+  {
+    id: 'fraud_sub_1',
+    merchantId: 'merch_nova',
+    merchantName: 'Nova Stream',
+    subscriberId: 'sub_ada',
+    subscriptionName: 'Studio Plan',
+    currency: 'USD',
+    amount: 29,
+    createdAt: '2026-04-22T09:00:00.000Z',
+    expectedUsage: 8,
+    observedUsage: 25,
+    chargebacks: 0,
+    riskScore: 78,
+    action: 'flag',
+    reason: 'Usage burst and fast creation cadence',
+    usagePattern: 'burst',
+    signals: [
+      { kind: 'velocity', score: 28, detail: 'Created alongside two other subscriptions', observedAt: nowIso() },
+      { kind: 'usage-anomaly', score: 30, detail: 'Observed usage is 3x the expected baseline', observedAt: nowIso() },
+      { kind: 'chargeback', score: 20, detail: 'Recent dispute behavior is elevated', observedAt: nowIso() },
+    ],
+    isBlocked: false,
+    isFlagged: true,
+  },
+  {
+    id: 'fraud_sub_2',
+    merchantId: 'merch_nova',
+    merchantName: 'Nova Stream',
+    subscriberId: 'sub_ada',
+    subscriptionName: 'Team Analytics',
+    currency: 'USD',
+    amount: 59,
+    createdAt: '2026-04-22T11:10:00.000Z',
+    expectedUsage: 10,
+    observedUsage: 6,
+    chargebacks: 1,
+    riskScore: 84,
+    action: 'block',
+    reason: 'Chargeback history and rapid subscription creation',
+    usagePattern: 'erratic',
+    signals: [
+      { kind: 'velocity', score: 35, detail: 'Second subscription within the same day', observedAt: nowIso() },
+      { kind: 'chargeback', score: 35, detail: 'Chargeback history predicts blocked outcome', observedAt: nowIso() },
+    ],
+    isBlocked: true,
+    isFlagged: true,
+  },
+  {
+    id: 'fraud_sub_3',
+    merchantId: 'merch_orbit',
+    merchantName: 'Orbit Tools',
+    subscriberId: 'sub_mina',
+    subscriptionName: 'Pro Builder',
+    currency: 'USD',
+    amount: 19,
+    createdAt: '2026-04-18T08:30:00.000Z',
+    expectedUsage: 12,
+    observedUsage: 12,
+    chargebacks: 0,
+    riskScore: 18,
+    action: 'approve',
+    reason: 'Usage profile is stable',
+    usagePattern: 'normal',
+    signals: [{ kind: 'velocity', score: 6, detail: 'Low velocity but within threshold', observedAt: nowIso() }],
+    isBlocked: false,
+    isFlagged: false,
+  },
+  {
+    id: 'fraud_sub_4',
+    merchantId: 'merch_cipher',
+    merchantName: 'Cipher Pro',
+    subscriberId: 'sub_jon',
+    subscriptionName: 'Automation Pack',
+    currency: 'USD',
+    amount: 99,
+    createdAt: '2026-04-24T07:00:00.000Z',
+    expectedUsage: 4,
+    observedUsage: 19,
+    chargebacks: 2,
+    riskScore: 92,
+    action: 'block',
+    reason: 'Chargeback prediction and anomalous usage behavior',
+    usagePattern: 'burst',
+    signals: [
+      { kind: 'usage-anomaly', score: 30, detail: 'Observed usage is far above baseline', observedAt: nowIso() },
+      { kind: 'chargeback', score: 35, detail: 'Repeated disputes indicate high risk', observedAt: nowIso() },
+      { kind: 'velocity', score: 27, detail: 'Fast subscription creation detected', observedAt: nowIso() },
+    ],
+    isBlocked: true,
+    isFlagged: true,
+  },
+];
+
+const reviewSeeds: FraudCase[] = [
+  {
+    caseId: 'fraud_sub_1',
+    subscriptionId: 'fraud_sub_1',
+    subscriberId: 'sub_ada',
+    merchantId: 'merch_nova',
+    merchantName: 'Nova Stream',
+    subscriptionName: 'Studio Plan',
+    riskScore: 78,
+    action: 'flag',
+    status: 'pending',
+    reason: 'Usage burst and fast creation cadence',
+    createdAt: '2026-04-22T09:05:00.000Z',
+    updatedAt: '2026-04-22T09:05:00.000Z',
+    notes: 'Auto-flagged for analyst review',
+  },
+  {
+    caseId: 'fraud_sub_2',
+    subscriptionId: 'fraud_sub_2',
+    subscriberId: 'sub_ada',
+    merchantId: 'merch_nova',
+    merchantName: 'Nova Stream',
+    subscriptionName: 'Team Analytics',
+    riskScore: 84,
+    action: 'block',
+    status: 'escalated',
+    reason: 'Chargeback history and rapid subscription creation',
+    createdAt: '2026-04-22T11:15:00.000Z',
+    updatedAt: '2026-04-22T11:15:00.000Z',
+    notes: 'Blocked automatically',
+  },
+  {
+    caseId: 'fraud_sub_4',
+    subscriptionId: 'fraud_sub_4',
+    subscriberId: 'sub_jon',
+    merchantId: 'merch_cipher',
+    merchantName: 'Cipher Pro',
+    subscriptionName: 'Automation Pack',
+    riskScore: 92,
+    action: 'block',
+    status: 'escalated',
+    reason: 'Chargeback prediction and anomalous usage behavior',
+    createdAt: '2026-04-24T07:05:00.000Z',
+    updatedAt: '2026-04-24T07:05:00.000Z',
+    notes: 'High confidence block',
+  },
+];
+
+const averageRisk = (items: FraudSubscriptionRecord[]): number =>
+  items.length ? Math.round(items.reduce((sum, item) => sum + item.riskScore, 0) / items.length) : 0;
+
+const computeAnalytics = (subscriptions: FraudSubscriptionRecord[], reviewQueue: FraudCase[]): FraudAnalytics => {
+  const approved = subscriptions.filter((item) => item.action === 'approve').length;
+  const flagged = subscriptions.filter((item) => item.action === 'flag').length;
+  const blocked = subscriptions.filter((item) => item.action === 'block').length;
+  const velocityAlerts = subscriptions.filter((item) =>
+    item.signals.some((signal) => signal.kind === 'velocity')
+  ).length;
+  const anomalyAlerts = subscriptions.filter((item) =>
+    item.signals.some((signal) => signal.kind === 'usage-anomaly')
+  ).length;
+  const chargebackPredictions = subscriptions.filter((item) =>
+    item.signals.some((signal) => signal.kind === 'chargeback')
+  ).length;
+
+  return {
+    totalChecks: subscriptions.length,
+    approved,
+    flagged,
+    blocked,
+    manualReviews: reviewQueue.length,
+    avgRisk: averageRisk(subscriptions),
+    velocityAlerts,
+    anomalyAlerts,
+    chargebackPredictions,
+    falsePositiveEstimate: Math.max(0, Math.round(flagged * 0.18)),
+  };
+};
+
+const scoreSubscription = (item: FraudSubscriptionRecord): FraudRiskScore => ({
+  subscriberId: item.subscriberId,
+  subscriptionId: item.id,
+  merchantId: item.merchantId,
+  merchantName: item.merchantName,
+  totalScore: item.riskScore,
+  velocityScore: item.signals.find((signal) => signal.kind === 'velocity')?.score ?? 0,
+  anomalyScore: item.signals.find((signal) => signal.kind === 'usage-anomaly')?.score ?? 0,
+  chargebackScore: item.signals.find((signal) => signal.kind === 'chargeback')?.score ?? 0,
+  action: item.action,
+  reason: item.reason,
+  assessedAt: item.createdAt,
+  signals: item.signals,
+});
+
+const cloneCase = (entry: FraudCase): FraudCase => ({ ...entry, notes: entry.notes });
+
+interface FraudState {
+  merchants: FraudMerchantRecord[];
+  subscriptions: FraudSubscriptionRecord[];
+  assessments: FraudRiskScore[];
+  reviewQueue: FraudCase[];
+  analytics: FraudAnalytics;
+  loading: boolean;
+  error: string | null;
+  refreshFraudSignals: () => void;
+  assessRisk: (subscriberId: string) => FraudRiskScore[];
+  flagSubscription: (subscriptionId: string) => void;
+  approveSubscription: (subscriptionId: string) => void;
+  blockSubscription: (subscriptionId: string) => void;
+  resolveCase: (subscriptionId: string, action: FraudAction) => void;
+  getFraudReport: (merchantId: string) => FraudReport;
+}
+
+const hydrateAssessments = (subscriptions: FraudSubscriptionRecord[]): FraudRiskScore[] =>
+  subscriptions.map((item) => scoreSubscription(item));
+
+const hydrateReviewQueue = (reviews: FraudCase[]): FraudCase[] => reviews.map(cloneCase);
+
+const updateSubscription = (
+  subscriptions: FraudSubscriptionRecord[],
+  subscriptionId: string,
+  patch: Partial<FraudSubscriptionRecord>
+): FraudSubscriptionRecord[] =>
+  subscriptions.map((item) => (item.id === subscriptionId ? { ...item, ...patch } : item));
+
+const buildMerchantReport = (
+  merchants: FraudMerchantRecord[],
+  subscriptions: FraudSubscriptionRecord[],
+  reviewQueue: FraudCase[],
+  merchantId: string
+): FraudReport => {
+  const merchant = merchants.find((item) => item.id === merchantId);
+  const merchantName = merchant?.name ?? 'Unknown merchant';
+  const scoped = subscriptions.filter((item) => item.merchantId === merchantId);
+  const scopedCases = reviewQueue.filter((entry) => entry.merchantId === merchantId);
+
+  return {
+    merchantId,
+    merchantName,
+    totalSubscriptions: scoped.length,
+    flaggedSubscriptions: scoped.filter((item) => item.action === 'flag').length,
+    blockedSubscriptions: scoped.filter((item) => item.action === 'block').length,
+    manualReviewCount: scopedCases.filter((item) => item.status !== 'reviewed').length,
+    averageRisk: averageRisk(scoped),
+    velocityAlerts: scoped.filter((item) => item.signals.some((signal) => signal.kind === 'velocity')).length,
+    anomalyAlerts: scoped.filter((item) => item.signals.some((signal) => signal.kind === 'usage-anomaly')).length,
+    chargebackPredictions: scoped.filter((item) => item.signals.some((signal) => signal.kind === 'chargeback')).length,
+    highRiskSubscribers: new Set(scoped.filter((item) => item.riskScore >= 50).map((item) => item.subscriberId)).size,
+    recentCases: scopedCases.slice(0, 5),
+  };
+};
+
+export const useFraudStore = create<FraudState>()(
+  persist(
+    (set, get) => ({
+      merchants: merchantSeeds.map((merchant) => ({ ...merchant })),
+      subscriptions: subscriptionSeeds.map((item) => ({ ...item, signals: item.signals.map((signal) => ({ ...signal })) })),
+      assessments: hydrateAssessments(subscriptionSeeds),
+      reviewQueue: hydrateReviewQueue(reviewSeeds),
+      analytics: computeAnalytics(subscriptionSeeds, reviewSeeds),
+      loading: false,
+      error: null,
+
+      refreshFraudSignals: () => {
+        const { subscriptions, reviewQueue, merchants } = get();
+        set({
+          analytics: computeAnalytics(subscriptions, reviewQueue),
+          assessments: hydrateAssessments(subscriptions),
+          merchants: merchants.map((merchant) => ({
+            ...merchant,
+            averageRisk: buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).averageRisk,
+            blockedSubscriptions: buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).blockedSubscriptions,
+            activeSubscriptions: buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).totalSubscriptions,
+            status:
+              buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).averageRisk >= 60
+                ? 'high-risk'
+                : buildMerchantReport(merchants, subscriptions, reviewQueue, merchant.id).averageRisk >= 35
+                  ? 'watch'
+                  : 'healthy',
+          })),
+        });
+      },
+
+      assessRisk: (subscriberId: string) => {
+        const assessments = get()
+          .subscriptions.filter((item) => item.subscriberId === subscriberId)
+          .map((item) => scoreSubscription(item));
+
+        set((state) => ({
+          assessments: [
+            ...state.assessments.filter((item) => item.subscriberId !== subscriberId),
+            ...assessments,
+          ],
+          analytics: computeAnalytics(state.subscriptions, state.reviewQueue),
+        }));
+
+        return assessments;
+      },
+
+      flagSubscription: (subscriptionId: string) => {
+        const current = get().subscriptions.find((item) => item.id === subscriptionId);
+        if (!current) return;
+
+        const score = scoreSubscription(current);
+        const nextCase: FraudCase = {
+          caseId: subscriptionId,
+          subscriptionId,
+          subscriberId: current.subscriberId,
+          merchantId: current.merchantId,
+          merchantName: current.merchantName,
+          subscriptionName: current.subscriptionName,
+          riskScore: score.totalScore,
+          action: score.totalScore >= 80 ? 'block' : 'flag',
+          status: score.totalScore >= 80 ? 'escalated' : 'pending',
+          reason: score.reason,
+          createdAt: nowIso(),
+          updatedAt: nowIso(),
+          notes: 'Manually queued for analyst review',
+        };
+
+        set((state) => ({
+          subscriptions: updateSubscription(state.subscriptions, subscriptionId, {
+            action: nextCase.action,
+            isFlagged: true,
+            isBlocked: nextCase.action === 'block',
+          }),
+          reviewQueue: [nextCase, ...state.reviewQueue.filter((entry) => entry.subscriptionId !== subscriptionId)],
+          analytics: computeAnalytics(
+            updateSubscription(state.subscriptions, subscriptionId, {
+              action: nextCase.action,
+              isFlagged: true,
+              isBlocked: nextCase.action === 'block',
+            }),
+            [nextCase, ...state.reviewQueue.filter((entry) => entry.subscriptionId !== subscriptionId)]
+          ),
+        }));
+      },
+
+      approveSubscription: (subscriptionId: string) => {
+        set((state) => {
+          const subscriptions = updateSubscription(state.subscriptions, subscriptionId, {
+            action: 'approve',
+            isFlagged: false,
+            isBlocked: false,
+          });
+          const reviewQueue = state.reviewQueue.map((entry) =>
+            entry.subscriptionId === subscriptionId
+              ? { ...entry, status: 'reviewed', action: 'approve', updatedAt: nowIso() }
+              : entry
+          );
+          return {
+            subscriptions,
+            reviewQueue,
+            analytics: computeAnalytics(subscriptions, reviewQueue),
+          };
+        });
+      },
+
+      blockSubscription: (subscriptionId: string) => {
+        set((state) => {
+          const subscriptions = updateSubscription(state.subscriptions, subscriptionId, {
+            action: 'block',
+            isFlagged: true,
+            isBlocked: true,
+          });
+          const reviewQueue = state.reviewQueue.map((entry) =>
+            entry.subscriptionId === subscriptionId
+              ? { ...entry, status: 'escalated', action: 'block', updatedAt: nowIso() }
+              : entry
+          );
+          return {
+            subscriptions,
+            reviewQueue,
+            analytics: computeAnalytics(subscriptions, reviewQueue),
+          };
+        });
+      },
+
+      resolveCase: (subscriptionId: string, action: FraudAction) => {
+        set((state) => {
+          const subscriptions = updateSubscription(state.subscriptions, subscriptionId, {
+            action,
+            isFlagged: action !== 'approve',
+            isBlocked: action === 'block',
+          });
+          const reviewQueue = state.reviewQueue.map((entry) =>
+            entry.subscriptionId === subscriptionId
+              ? {
+                  ...entry,
+                  action,
+                  status: action === 'approve' ? 'reviewed' : action === 'block' ? 'escalated' : 'pending',
+                  updatedAt: nowIso(),
+                }
+              : entry
+          );
+          return {
+            subscriptions,
+            reviewQueue,
+            analytics: computeAnalytics(subscriptions, reviewQueue),
+          };
+        });
+      },
+
+      getFraudReport: (merchantId: string) =>
+        buildMerchantReport(get().merchants, get().subscriptions, get().reviewQueue, merchantId),
+    }),
+    {
+      name: STORAGE_KEY,
+      storage: createJSONStorage(() => AsyncStorage),
+    }
+  )
+);
diff --git a/src/store/index.ts b/src/store/index.ts
index 22c0e46..af7cffd 100644
--- a/src/store/index.ts
+++ b/src/store/index.ts
@@ -4,10 +4,4 @@ export { useTransactionQueueStore } from './transactionQueueStore';
 export { useWalletStore } from './walletStore';
 export { useNetworkStore } from './networkStore';
 export { useCommunityStore } from './communityStore';
-export { useAccountingStore } from './accountingStore';
-export { useCalendarStore } from './calendarStore';
-export { useSettingsStore } from './settingsStore';
-export { useMerchantStore } from './merchantStore';
-export { useAffiliateStore } from './affiliateStore';
-export { useLoyaltyStore } from './loyaltyStore';
-export { useCampaignStore } from './campaignStore';
+export { useFraudStore } from './fraudStore';
diff --git a/src/types/fraud.ts b/src/types/fraud.ts
new file mode 100644
index 0000000..818042e
--- /dev/null
+++ b/src/types/fraud.ts
@@ -0,0 +1,100 @@
+export type FraudAction = 'approve' | 'flag' | 'block';
+export type FraudReviewStatus = 'pending' | 'reviewed' | 'dismissed' | 'escalated';
+export type FraudSignalType = 'velocity' | 'usage-anomaly' | 'chargeback' | 'pattern-shift' | 'device-mismatch';
+
+export interface FraudSignal {
+  kind: FraudSignalType;
+  score: number;
+  detail: string;
+  observedAt: string;
+}
+
+export interface FraudRiskScore {
+  subscriberId: string;
+  subscriptionId: string;
+  merchantId: string;
+  merchantName: string;
+  totalScore: number;
+  velocityScore: number;
+  anomalyScore: number;
+  chargebackScore: number;
+  action: FraudAction;
+  reason: string;
+  assessedAt: string;
+  signals: FraudSignal[];
+}
+
+export interface FraudCase {
+  caseId: string;
+  subscriptionId: string;
+  subscriberId: string;
+  merchantId: string;
+  merchantName: string;
+  subscriptionName: string;
+  riskScore: number;
+  action: FraudAction;
+  status: FraudReviewStatus;
+  reason: string;
+  createdAt: string;
+  updatedAt: string;
+  notes?: string;
+}
+
+export interface FraudReport {
+  merchantId: string;
+  merchantName: string;
+  totalSubscriptions: number;
+  flaggedSubscriptions: number;
+  blockedSubscriptions: number;
+  manualReviewCount: number;
+  averageRisk: number;
+  velocityAlerts: number;
+  anomalyAlerts: number;
+  chargebackPredictions: number;
+  highRiskSubscribers: number;
+  recentCases: FraudCase[];
+}
+
+export interface FraudSubscriptionRecord {
+  id: string;
+  merchantId: string;
+  merchantName: string;
+  subscriberId: string;
+  subscriptionName: string;
+  currency: string;
+  amount: number;
+  createdAt: string;
+  expectedUsage: number;
+  observedUsage: number;
+  chargebacks: number;
+  riskScore: number;
+  action: FraudAction;
+  reason: string;
+  usagePattern: 'normal' | 'burst' | 'erratic';
+  signals: FraudSignal[];
+  isBlocked: boolean;
+  isFlagged: boolean;
+}
+
+export interface FraudMerchantRecord {
+  id: string;
+  name: string;
+  status: 'healthy' | 'watch' | 'high-risk';
+  activeSubscriptions: number;
+  blockedSubscriptions: number;
+  averageRisk: number;
+  monthlyVolume: number;
+}
+
+export interface FraudAnalytics {
+  totalChecks: number;
+  approved: number;
+  flagged: number;
+  blocked: number;
+  manualReviews: number;
+  avgRisk: number;
+  velocityAlerts: number;
+  anomalyAlerts: number;
+  chargebackPredictions: number;
+  falsePositiveEstimate: number;
+}