import React, { useState, useEffect } from "react" import { callAI } from "call-ai" import { useFireproof } from "use-fireproof" export default function App() { const { database, useLiveQuery, useDocument } = useFireproof("fraud-detection-db") const [activeTab, setActiveTab] = useState("dashboard") const [analyzing, setAnalyzing] = useState(false) const [currentLocation, setCurrentLocation] = useState(null) const [locationError, setLocationError] = useState(null) const [locationPermission, setLocationPermission] = useState("pending") const [notifyingBank, setNotifyingBank] = useState(false) // Transaction input form const { doc: newTx, merge: mergeNewTx, submit: submitNewTx } = useDocument({ type: "transaction", amount: "", merchant: "", location: "", category: "", paymentMethodId: "", timestamp: Date.now() }) // Payment method form const { doc: newPayment, merge: mergeNewPayment, submit: submitNewPayment } = useDocument({ type: "payment_method", accountType: "", cardType: "", last4: "", nickname: "", bankName: "", bankContactEmail: "", bankContactPhone: "", accountNumber: "", isActive: true, isFrozen: false, addedDate: Date.now() }) // AI Configuration const { doc: config, merge: mergeConfig, save: saveConfig } = useDocument({ _id: "fraud-config", type: "config", sensitivityLevel: "medium", autoBlock: false, autoNotifyBank: true, amountThreshold: 1000, velocityWindow: 3600000, geoAnomalyDetection: true, locationTracking: true, locationRadius: 50, crossAccountMonitoring: true, duplicateDetection: true, instantFreeze: false }) // Get payment methods const { docs: paymentMethods } = useLiveQuery("type", { key: "payment_method", descending: true }) // Get recent transactions const { docs: transactions } = useLiveQuery("type", { key: "transaction", descending: true, limit: 100 }) // Get fraud alerts const { docs: alerts } = useLiveQuery("type", { key: "alert", descending: true, limit: 20 }) // Get blocked transactions const { docs: blocked } = useLiveQuery("type", { key: "blocked", descending: true, limit: 10 }) // Get location history const { docs: locationHistory } = useLiveQuery("type", { key: "location", descending: true, limit: 100 }) // Get bank notifications const { docs: bankNotifications } = useLiveQuery("type", { key: "bank_notification", descending: true, limit: 50 }) // Request and track location useEffect(() => { if (!config.locationTracking) return const requestLocation = () => { if (!navigator.geolocation) { setLocationError("Geolocation not supported by browser") setLocationPermission("denied") return } navigator.geolocation.getCurrentPosition( async (position) => { const locationData = { latitude: position.coords.latitude, longitude: position.coords.longitude, accuracy: position.coords.accuracy, timestamp: Date.now() } setCurrentLocation(locationData) setLocationError(null) setLocationPermission("granted") try { const response = await fetch( `https://nominatim.openstreetmap.org/reverse?lat=${locationData.latitude}&lon=${locationData.longitude}&format=json` ) const data = await response.json() const address = data.address const cityState = `${address.city || address.town || address.village || ''}, ${address.state || address.country || ''}` await database.put({ type: "location", ...locationData, city: address.city || address.town || address.village, state: address.state, country: address.country, displayName: cityState, timestamp: Date.now() }) setCurrentLocation({ ...locationData, displayName: cityState }) } catch (error) { console.error("Geocoding error:", error) } }, (error) => { setLocationError(error.message) setLocationPermission("denied") }, { enableHighAccuracy: true, timeout: 5000, maximumAge: 300000 } ) } requestLocation() const intervalId = setInterval(requestLocation, 300000) return () => clearInterval(intervalId) }, [config.locationTracking, database]) const isLocationTrusted = (txLocation) => { if (!config.locationTracking || !txLocation) return null const recentLocations = locationHistory.slice(0, 20) for (const loc of recentLocations) { if (loc.displayName && txLocation.includes(loc.city || '')) { return { trusted: true, matchedLocation: loc.displayName } } } return { trusted: false, matchedLocation: null } } const detectDuplicateTransactions = (transaction) => { const recentWindow = 3600000 const recentTxs = transactions.filter(tx => tx._id !== transaction._id && Math.abs(tx.timestamp - transaction.timestamp) < recentWindow ) const duplicates = recentTxs.filter(tx => Math.abs(parseFloat(tx.amount) - parseFloat(transaction.amount)) < 0.01 && tx.merchant.toLowerCase() === transaction.merchant.toLowerCase() ) return duplicates } // Notify bank and freeze account const notifyBankAndFreeze = async (alert, paymentMethod, autoFreeze = false) => { setNotifyingBank(true) try { // Generate notification message using AI const notificationResponse = await callAI([{ role: "user", content: `Generate a professional fraud notification message for a bank. Transaction Details: - Amount: $${alert.transaction.amount} - Merchant: ${alert.transaction.merchant} - Location: ${alert.transaction.location} - Date/Time: ${new Date(alert.transaction.timestamp).toLocaleString()} - Risk Score: ${alert.analysis.riskScore}% Payment Method: - ${paymentMethod.nickname} - ${paymentMethod.cardType} ${paymentMethod.accountType} ending in ${paymentMethod.last4} - Bank: ${paymentMethod.bankName} Customer Location: - Actual location at transaction time: ${alert.currentUserLocation || "Unknown"} Fraud Indicators: ${alert.analysis.indicators.join(", ")} Action Requested: ${autoFreeze ? "IMMEDIATE ACCOUNT FREEZE" : "FRAUD ALERT - MANUAL REVIEW"} Generate a clear, professional notification message that includes all relevant details and requested action.` }], { schema: { properties: { subject: { type: "string", description: "Email subject line" }, message: { type: "string", description: "Full notification message" }, urgency: { type: "string", description: "critical, high, or medium" } } } }) const notification = JSON.parse(notificationResponse) // Save notification record const notificationDoc = await database.put({ type: "bank_notification", alertId: alert._id, paymentMethodId: paymentMethod._id, status: "sent", method: "email_and_phone", subject: notification.subject, message: notification.message, urgency: notification.urgency, bankName: paymentMethod.bankName, bankEmail: paymentMethod.bankContactEmail, bankPhone: paymentMethod.bankContactPhone, accountLast4: paymentMethod.last4, freezeRequested: autoFreeze, sentAt: Date.now(), transaction: alert.transaction, riskScore: alert.analysis.riskScore }) // Update payment method status if freeze requested if (autoFreeze) { await database.put({ ...paymentMethod, isFrozen: true, frozenAt: Date.now(), frozenReason: `Fraud detected: ${alert.transaction.merchant} - $${alert.transaction.amount}` }) } // Update alert with notification info await database.put({ ...alert, bankNotified: true, notificationId: notificationDoc.id, accountFrozen: autoFreeze, notifiedAt: Date.now() }) return { success: true, notification } } catch (error) { console.error("Bank notification error:", error) return { success: false, error: error.message } } finally { setNotifyingBank(false) } } const analyzeTransaction = async (transaction) => { setAnalyzing(true) try { const paymentMethod = paymentMethods.find(pm => pm._id === transaction.paymentMethodId) const recentTransactions = transactions .filter(t => t._id !== transaction._id) .slice(0, 10) .map(t => ({ amount: t.amount, merchant: t.merchant, location: t.location, category: t.category, paymentMethod: paymentMethods.find(pm => pm._id === t.paymentMethodId)?.nickname || "Unknown" })) const locationTrust = isLocationTrusted(transaction.location) const recentUserLocations = locationHistory.slice(0, 10).map(l => l.displayName || `${l.latitude}, ${l.longitude}`) const duplicates = detectDuplicateTransactions(transaction) const sameCardTxs = transactions .filter(t => t.paymentMethodId === transaction.paymentMethodId) .slice(0, 5) const response = await callAI([{ role: "user", content: `Analyze this transaction for fraud potential: Current Transaction: - Amount: $${transaction.amount} - Merchant: ${transaction.merchant} - Location: ${transaction.location} - Category: ${transaction.category} - Payment Method: ${paymentMethod?.nickname || "Unknown"} (${paymentMethod?.cardType || "Unknown"} ${paymentMethod?.accountType || ""} ending in ${paymentMethod?.last4 || "****"}) Location Context: - User's Current Location: ${currentLocation?.displayName || "Unknown"} - Transaction Location Trusted: ${locationTrust?.trusted ? "YES - Matches recent user location" : "NO - Does not match recent locations"} - Recent User Locations (last 10): ${recentUserLocations.join(", ")} Payment Method Analysis: - Recent transactions on this card: ${sameCardTxs.length} - Duplicate Detection: ${duplicates.length > 0 ? `FOUND ${duplicates.length} similar transaction(s) within 1 hour on different payment methods` : "No duplicates detected"} Recent Transaction History: ${JSON.stringify(recentTransactions, null, 2)} Configuration: - Sensitivity: ${config.sensitivityLevel} - Amount Threshold: $${config.amountThreshold} IMPORTANT: 1. If the transaction location matches recent user locations, reduce risk unless other red flags exist. 2. Duplicate transactions on different accounts = CRITICAL fraud indicator. 3. Consider the payment method's transaction history. Provide fraud analysis with risk score (0-100), key indicators, and recommendation.` }], { schema: { properties: { riskScore: { type: "number", description: "Risk score from 0-100" }, riskLevel: { type: "string", description: "low, medium, high, or critical" }, indicators: { type: "array", items: { type: "string" }, description: "List of fraud indicators found" }, recommendation: { type: "string", description: "allow, review, or block" }, reasoning: { type: "string", description: "Brief explanation of the decision" }, locationMatch: { type: "boolean", description: "Whether transaction location matches user's recent locations" } } } }) const analysis = JSON.parse(response) if (duplicates.length > 0) { analysis.riskScore = Math.min(100, analysis.riskScore + 30) analysis.indicators.push(`Duplicate transaction detected on ${duplicates.length} other account(s)`) } const shouldAlert = analysis.riskScore >= 30 if (shouldAlert) { const alertDoc = await database.put({ type: "alert", transactionId: transaction._id, transaction: transaction, analysis: analysis, locationTrust: locationTrust, currentUserLocation: currentLocation?.displayName, paymentMethod: paymentMethod, duplicates: duplicates.length, status: "pending", timestamp: Date.now() }) // Auto-notify bank if configured and high risk if (config.autoNotifyBank && analysis.riskScore >= 75) { await notifyBankAndFreeze( { ...alertDoc, _id: alertDoc.id }, paymentMethod, config.instantFreeze ) } } if (config.autoBlock && analysis.recommendation === "block") { await database.put({ type: "blocked", transactionId: transaction._id, transaction: transaction, analysis: analysis, locationTrust: locationTrust, paymentMethod: paymentMethod, timestamp: Date.now() }) } await database.put({ ...transaction, analysis: analysis, locationTrust: locationTrust, analyzed: true }) } catch (error) { console.error("Analysis error:", error) } finally { setAnalyzing(false) } } const handleSubmitTransaction = async (e) => { e.preventDefault() if (newTx.amount && newTx.merchant && newTx.paymentMethodId) { await submitNewTx() const savedTx = await database.get((await database.query("type", { key: "transaction", limit: 1, descending: true })).docs[0]._id) await analyzeTransaction(savedTx) } } const handleSubmitPaymentMethod = async (e) => { e.preventDefault() if (newPayment.accountType && newPayment.last4) { await submitNewPayment() } } const togglePaymentMethodStatus = async (paymentMethod) => { await database.put({ ...paymentMethod, isActive: !paymentMethod.isActive }) } const unfreezeAccount = async (paymentMethod) => { if (confirm(`Are you sure you want to unfreeze ${paymentMethod.nickname}? Only do this if the fraud alert was confirmed as a false alarm.`)) { await database.put({ ...paymentMethod, isFrozen: false, unfrozenAt: Date.now() }) } } const deletePaymentMethod = async (paymentMethodId) => { if (confirm("Are you sure you want to delete this payment method?")) { await database.del(paymentMethodId) } } const markAlertResolved = async (alert, isFalseAlarm) => { const paymentMethod = paymentMethods.find(pm => pm._id === alert.transaction.paymentMethodId) if (!isFalseAlarm) { // Confirmed fraud - notify bank and freeze await notifyBankAndFreeze(alert, paymentMethod, true) } await database.put({ ...alert, status: "resolved", resolution: isFalseAlarm ? "false_alarm" : "confirmed_fraud", resolvedAt: Date.now() }) } const getRiskColor = (score) => { if (score >= 75) return "bg-[#ff4444] text-[#ffffff]" if (score >= 50) return "bg-[#ff8844] text-[#0f172a]" if (score >= 30) return "bg-[#ffbb44] text-[#0f172a]" return "bg-[#44ff88] text-[#0f172a]" } const getCardIcon = (cardType) => { const icons = { visa: "💳", mastercard: "💳", amex: "💳", discover: "💳", debit: "💰", credit: "💳" } return icons[cardType?.toLowerCase()] || "💳" } const stats = { totalTransactions: transactions.length, alertsActive: alerts.filter(a => a.status === "pending").length, blockedCount: blocked.length, falseAlarmRate: alerts.filter(a => a.resolution === "false_alarm").length / Math.max(alerts.length, 1) * 100, locationVerified: transactions.filter(t => t.locationTrust?.trusted).length, activePaymentMethods: paymentMethods.filter(pm => pm.isActive && !pm.isFrozen).length, frozenAccounts: paymentMethods.filter(pm => pm.isFrozen).length, bankNotifications: bankNotifications.length } const autoFillCurrentLocation = () => { if (currentLocation?.displayName) { mergeNewTx({ location: currentLocation.displayName }) } } const activePaymentMethods = paymentMethods.filter(pm => pm.isActive && !pm.isFrozen) const frozenPaymentMethods = paymentMethods.filter(pm => pm.isFrozen) const inactivePaymentMethods = paymentMethods.filter(pm => !pm.isActive && !pm.isFrozen) return (

{/* Header */}

🛡️ TRUSTSHIELD AI

Real-time fraud detection with instant bank notification & account freezing

📍 {locationPermission === "granted" ? `TRACKING: ${currentLocation?.displayName || "Getting location..."}` : locationPermission === "denied" ? "LOCATION DISABLED" : "REQUESTING LOCATION..."}

💳 {activePaymentMethods.length} ACTIVE

{frozenPaymentMethods.length > 0 && (

🔒 {frozenPaymentMethods.length} FROZEN

)} {currentLocation && (

Accuracy: ±{Math.round(currentLocation.accuracy)}m

)}

{locationError && (

⚠️ {locationError}

)}

{/* Tab Navigation */}

{["dashboard", "accounts", "transactions", "alerts", "notifications", "locations", "config"].map(tab => ( ))}

{/* Dashboard Tab */} {activeTab === "dashboard" && (

{/* Stats Grid */}

ACTIVE

{stats.activePaymentMethods}

FROZEN

{stats.frozenAccounts}

TOTAL TXS

{stats.totalTransactions}

ALERTS

{stats.alertsActive}

BLOCKED

{stats.blockedCount}

VERIFIED

{stats.locationVerified}

NOTIFIED

{stats.bankNotifications}

{/* Frozen Accounts Alert */} {frozenPaymentMethods.length > 0 && (

🔒 FROZEN ACCOUNTS

{frozenPaymentMethods.map(pm => (

🔒 {pm.nickname} - FROZEN

••••{pm.last4} • {pm.bankName}

Reason: {pm.frozenReason || "Fraud detected"}

Frozen: {new Date(pm.frozenAt).toLocaleString()}

))}

)} {activePaymentMethods.length === 0 && frozenPaymentMethods.length === 0 && (

⚠️ NO PAYMENT METHODS LINKED

Add your credit cards, debit cards, and bank accounts to start monitoring for fraud with instant bank notification capabilities.

)} {/* New Transaction Form */}

⚡ NEW TRANSACTION

Payment Method *

Amount ($) * mergeNewTx({ amount: e.target.value })} className="w-full p-3 border-4 border-[#0f172a] font-bold" placeholder="0.00" required />

Merchant * mergeNewTx({ merchant: e.target.value })} className="w-full p-3 border-4 border-[#0f172a] font-bold" placeholder="Amazon, Walmart, etc." required />

Location

mergeNewTx({ location: e.target.value })} className="flex-1 p-3 border-4 border-[#0f172a] font-bold" placeholder="New York, NY" /> {currentLocation?.displayName && ( )}

🚨 ACTIVE ALERTS

{alerts.filter(a => a.status === "pending").slice(0, 5).map(alert => { const pm = paymentMethods.find(p => p._id === alert.transaction.paymentMethodId) return (

${alert.transaction.amount} - {alert.transaction.merchant}

{pm && `${getCardIcon(pm.cardType)} ${pm.nickname} (••${pm.last4})`}

{alert.transaction.location}

{alert.locationTrust && (

{alert.locationTrust.trusted ? "✓ Location Verified" : "⚠ Unknown Location"}

)} {alert.duplicates > 0 && (

⚠️ {alert.duplicates} DUPLICATE TRANSACTION(S)

)} {alert.bankNotified && (

✓ Bank notified at {new Date(alert.notifiedAt).toLocaleString()}

)}

{alert.analysis.riskScore}%

{alert.analysis.reasoning}

{!alert.bankNotified && pm && ( )}

) })}

)}

)} {/* Accounts Tab */} {activeTab === "accounts" && (

💳 ADD PAYMENT METHOD

Link your accounts with bank contact information to enable instant fraud notifications and automatic account freezing when fraud is detected.

Account Type *

Card/Account Brand

Bank/Issuer Name * mergeNewPayment({ bankName: e.target.value })} className="w-full p-3 border-4 border-[#0f172a] font-bold" placeholder="Chase, Bank of America, etc." required />

Last 4 Digits * mergeNewPayment({ last4: e.target.value.replace(/\D/g, '') })} className="w-full p-3 border-4 border-[#0f172a] font-bold" placeholder="1234" required />

Bank Fraud Email mergeNewPayment({ bankContactEmail: e.target.value })} className="w-full p-3 border-4 border-[#0f172a] font-bold" placeholder="fraud@chase.com" />

For instant notifications

Bank Fraud Hotline mergeNewPayment({ bankContactPhone: e.target.value })} className="w-full p-3 border-4 border-[#0f172a] font-bold" placeholder="1-800-XXX-XXXX" />

For emergency freezing

Nickname * mergeNewPayment({ nickname: e.target.value })} className="w-full p-3 border-4 border-[#0f172a] font-bold" placeholder="My Chase Visa, Work Debit, etc." required />

{frozenPaymentMethods.length > 0 && (

🔒 FROZEN ACCOUNTS ({frozenPaymentMethods.length})

{frozenPaymentMethods.map(pm => { const txCount = transactions.filter(t => t.paymentMethodId === pm._id).length return (

🔒 {pm.nickname}

{pm.cardType && {pm.cardType}} {pm.cardType && pm.accountType && " • "} {pm.accountType && {pm.accountType}} {" • "}••••{pm.last4}

{pm.bankName && (

{pm.bankName}

)}

{pm.frozenReason || "Account frozen due to fraud"}

Frozen: {new Date(pm.frozenAt).toLocaleString()}

) })}

)} {activePaymentMethods.length > 0 && (

✓ ACTIVE ACCOUNTS ({activePaymentMethods.length})

{activePaymentMethods.map(pm => { const txCount = transactions.filter(t => t.paymentMethodId === pm._id).length const recentTx = transactions.filter(t => t.paymentMethodId === pm._id).slice(0, 1)[0] return (

{getCardIcon(pm.cardType)} {pm.nickname}

{pm.cardType && {pm.cardType}} {pm.cardType && pm.accountType && " • "} {pm.accountType && {pm.accountType}} {" • "}••••{pm.last4}

{pm.bankName && (

{pm.bankName}

)} {pm.bankContactEmail && (

✓ Bank notifications enabled

)}

{txCount} transaction{txCount !== 1 ? 's' : ''} {recentTx && ` • Last: ${new Date(recentTx.timestamp).toLocaleDateString()}`}

) })}

)} {inactivePaymentMethods.length > 0 && (

⏸ PAUSED ACCOUNTS ({inactivePaymentMethods.length})

{inactivePaymentMethods.map(pm => (

{getCardIcon(pm.cardType)} {pm.nickname}

{pm.cardType && {pm.cardType}} {pm.cardType && pm.accountType && " • "} {pm.accountType && {pm.accountType}} {" • "}••••{pm.last4}

))}

)}

)} {/* Transactions Tab */} {activeTab === "transactions" && (

📊 ALL TRANSACTIONS

{transactions.map(tx => { const pm = paymentMethods.find(p => p._id === tx.paymentMethodId) return (

${tx.amount} - {tx.merchant}

{pm && ( {getCardIcon(pm.cardType)} {pm.nickname} (••{pm.last4}) • )} {tx.location} • {tx.category}

{new Date(tx.timestamp).toLocaleString()}

{tx.locationTrust && (

{tx.locationTrust.trusted ? "✓ Location Match" : "⚠ Location Anomaly"}

)}

{tx.analysis && (

{tx.analysis.riskScore}% {tx.analysis.riskLevel}

)} {!tx.analyzed && ( )}

) })}

)} {/* Alerts Tab */} {activeTab === "alerts" && (

🚨 FRAUD ALERTS

{alerts.map(alert => { const pm = paymentMethods.find(p => p._id === alert.transaction.paymentMethodId) return (

${alert.transaction.amount} - {alert.transaction.merchant}

{pm && ( {getCardIcon(pm.cardType)} {pm.nickname} (••{pm.last4}) )}

{alert.transaction.location} • {new Date(alert.timestamp).toLocaleString()}

{alert.currentUserLocation && (

User was at: {alert.currentUserLocation}

)}

{alert.analysis.riskScore}% {alert.analysis.riskLevel}

Indicators:

{alert.analysis.indicators.map((ind, i) => ( {ind} ))} {alert.locationTrust?.trusted && ( ✓ LOCATION VERIFIED )} {alert.duplicates > 0 && ( ⚠️ {alert.duplicates} DUPLICATE(S) )} {alert.bankNotified && ( ✓ BANK NOTIFIED )} {alert.accountFrozen && ( 🔒 ACCOUNT FROZEN )}

{alert.analysis.reasoning}

{alert.status === "pending" ? "PENDING" : alert.resolution === "false_alarm" ? "FALSE ALARM" : "CONFIRMED FRAUD"}

{alert.status === "pending" && (

)}

) })}

)} {/* Notifications Tab */} {activeTab === "notifications" && (

📨 BANK NOTIFICATIONS

All fraud notifications sent to your financial institutions. These notifications eliminate the need for you to contact your bank directly - the system does it automatically.

{bankNotifications.map(notif => (

{notif.bankName}

Account ••{notif.accountLast4}

Sent: {new Date(notif.sentAt).toLocaleString()}

{notif.urgency.toUpperCase()}

{notif.freezeRequested && (

🔒 FREEZE REQUESTED

)}

{notif.subject}

{notif.message}

Contact Method: {notif.method.replace('_', ' & ')}

{notif.bankEmail &&

Email: {notif.bankEmail}

} {notif.bankPhone &&

Phone: {notif.bankPhone}

}

Transaction Details:

${notif.transaction.amount} at {notif.transaction.merchant} • Risk: {notif.riskScore}%

))} {bankNotifications.length === 0 && (

📭

No bank notifications yet

Notifications will appear here when fraud is detected and banks are notified

)}

)} {/* Locations Tab */} {activeTab === "locations" && (

📍 LOCATION HISTORY

{currentLocation && (

CURRENT LOCATION

Location: {currentLocation.displayName}

Coordinates: {currentLocation.latitude.toFixed(6)}, {currentLocation.longitude.toFixed(6)}

Accuracy: ±{Math.round(currentLocation.accuracy)} meters

Last Updated: {new Date(currentLocation.timestamp).toLocaleString()}

)}

Recent Locations ({locationHistory.length})

{locationHistory.map((loc, idx) => (

{loc.displayName || "Unknown Location"}

{loc.city && `${loc.city}, `}{loc.state || loc.country}

{loc.latitude.toFixed(6)}, {loc.longitude.toFixed(6)}

{new Date(loc.timestamp).toLocaleDateString()}

{new Date(loc.timestamp).toLocaleTimeString()}

±{Math.round(loc.accuracy)}m

))}

)} {/* Config Tab */} {activeTab === "config" && (

⚙️ AI CONFIGURATION

Sensitivity Level

Amount Threshold ($) mergeConfig({ amountThreshold: parseFloat(e.target.value) })} className="w-full p-3 border-4 border-[#0f172a] font-bold" />

Flag transactions above this amount

BANK NOTIFICATION SETTINGS

mergeConfig({ autoNotifyBank: e.target.checked })} className="w-6 h-6 border-4 border-[#0f172a]" /> Auto-notify banks on high-risk alerts

Automatically send fraud notifications to your bank when risk score ≥ 75%

mergeConfig({ instantFreeze: e.target.checked })} className="w-6 h-6 border-4 border-[#0f172a]" /> Instant account freeze on fraud confirmation

CRITICAL FEATURE: Immediately freeze accounts when fraud is confirmed - eliminates communication delay with your bank

LOCATION SETTINGS

mergeConfig({ locationTracking: e.target.checked })} className="w-6 h-6 border-4 border-[#0f172a]" /> Enable continuous location tracking

Track your location in real-time to verify transaction locations and reduce false alerts

mergeConfig({ geoAnomalyDetection: e.target.checked })} className="w-6 h-6 border-4 border-[#0f172a]" /> Enable geo-anomaly detection

Location Trust Radius (km) mergeConfig({ locationRadius: parseFloat(e.target.value) })} className="w-full p-3 border-4 border-[#0f172a] font-bold" />

MULTI-ACCOUNT MONITORING

mergeConfig({ crossAccountMonitoring: e.target.checked })} className="w-6 h-6 border-4 border-[#0f172a]" /> Enable cross-account fraud detection

mergeConfig({ duplicateDetection: e.target.checked })} className="w-6 h-6 border-4 border-[#0f172a]" /> Detect duplicate transactions

AUTO-BLOCKING

mergeConfig({ autoBlock: e.target.checked })} className="w-6 h-6 border-4 border-[#0f172a]" /> Auto-block high-risk transactions

)}

) }