dev sync with main

redirects.json

@@ -21,7 +21,12 @@
     },
     {
         "source": "/:path*",
-        "has": [{ "type": "host", "value": "docs.peanut.me" }],
+        "has": [
+            {
+                "type": "host",
+                "value": "docs.peanut.me"
+            }
+        ],
         "destination": "https://peanut.me/en/help",
         "permanent": true
     },
@@ -74,5 +79,15 @@
         "source": "/seedlings",
         "destination": "https://peanutprotocol.notion.site/Influencer-information-form-2af8381175798067b271cd95a04d922a",
         "permanent": false
+    },
+    {
+        "source": "/presskit",
+        "destination": "https://peanutprotocol.notion.site/Press-Kit-12f83811757981fc9ca5de581b20f50d",
+        "permanent": true
+    },
+    {
+        "source": "/press-kit",
+        "destination": "https://peanutprotocol.notion.site/Press-Kit-12f83811757981fc9ca5de581b20f50d",
+        "permanent": true
     }
 ]

scripts/validate-links.ts

@@ -42,12 +42,31 @@ function buildValidPaths(): Set<string> {
         paths.add(p)
     }
 
+    // App routes (behind auth / mobile-ui) — content may link to these
+    for (const p of [
+        '/profile',
+        '/profile/backup',
+        '/profile/edit',
+        '/profile/exchange-rate',
+        '/profile/identity-verification',
+        '/home',
+        '/send',
+        '/request',
+        '/settings',
+        '/history',
+        '/points',
+        '/recover-funds',
+    ]) {
+        paths.add(p)
+    }
+
     const countrySlugs = listDirs(path.join(CONTENT_DIR, 'countries'))
     const competitorSlugs = listDirs(path.join(CONTENT_DIR, 'compare'))
     const payWithSlugs = listDirs(path.join(CONTENT_DIR, 'pay-with'))
     const depositSlugs = listDirs(path.join(CONTENT_DIR, 'deposit'))
     const helpSlugs = listDirs(path.join(CONTENT_DIR, 'help'))
     const useCaseSlugs = listDirs(path.join(CONTENT_DIR, 'use-cases'))
+    const storySlugs = listDirs(path.join(CONTENT_DIR, 'stories')).filter((s) => s !== 'index')
     const withdrawSlugs = listDirs(path.join(CONTENT_DIR, 'withdraw'))
     const exchangeSlugs = listEntitySlugs('exchanges')
 
@@ -117,6 +136,14 @@ function buildValidPaths(): Set<string> {
             paths.add(`/${locale}/use-cases/${slug}`)
         }
 
+        // Stories: /{locale}/stories and /{locale}/stories/{slug}
+        if (storySlugs.length > 0) {
+            paths.add(`/${locale}/stories`)
+            for (const slug of storySlugs) {
+                paths.add(`/${locale}/stories/${slug}`)
+            }
+        }
+
         // Withdraw: /{locale}/withdraw/{slug}
         for (const slug of withdrawSlugs) {
             paths.add(`/${locale}/withdraw/to-${slug}`)

src/app/(mobile-ui)/qr-pay/page.tsx

@@ -700,7 +700,24 @@ export default function QRPayPage() {
                 clearTimeout(payingStateTimerRef.current)
                 payingStateTimerRef.current = null
             }
+            // Map backend field name (sponsoredUsd) to frontend field name (amountSponsored)
+            const perkResponse = qrPayment.perk as Record<string, unknown> | undefined
+            if (qrPayment.perk && typeof perkResponse?.sponsoredUsd === 'number') {
+                qrPayment.perk.amountSponsored = perkResponse.sponsoredUsd
+            }
+
             setQrPayment(qrPayment)
+
+            // Auto-claim small perks (<$0.50) — skip the hold-to-claim ceremony.
+            // The backend already claimed the perk at payment time, so this is just a UI shortcut.
+            if (
+                qrPayment.perk?.eligible &&
+                typeof qrPayment.perk.amountSponsored === 'number' &&
+                qrPayment.perk.amountSponsored < 0.5
+            ) {
+                setPerkClaimed(true)
+            }
+
             setIsSuccess(true)
         } catch (error) {
             // clear the timer on error to prevent race condition
@@ -1234,31 +1251,21 @@ export default function QRPayPage() {
                                 <h2 className="text-lg font-bold">Eligible for a Peanut Perk!</h2>
                                 <p className="text-sm text-gray-600">
                                     {(() => {
-                                        const percentage = qrPayment?.perk?.discountPercentage || 100
                                         const amountSponsored = qrPayment?.perk?.amountSponsored
                                         const transactionUsd =
                                             parseFloat(qrPayment?.details?.paymentAgainstAmount || '0') || 0
 
-                                        // Check if percentage matches the actual math (within 1% tolerance)
-                                        let percentageMatches = false
-                                        if (amountSponsored && transactionUsd > 0) {
-                                            const actualPercentage = (amountSponsored / transactionUsd) * 100
-                                            percentageMatches = Math.abs(actualPercentage - percentage) < 1
-                                        }
-
-                                        if (percentageMatches) {
-                                            if (percentage === 100) {
-                                                return 'This bill can be covered by Peanut. Claim it now to unlock your reward.'
-                                            } else if (percentage > 100) {
-                                                return `You're getting ${percentage}% back — that's more than you paid! Claim it now.`
-                                            } else {
-                                                return `You're getting ${percentage}% cashback! Claim it now to unlock your reward.`
+                                        // Always show actual dollar amount — never percentage (misleading due to dynamic caps)
+                                        // Note: perks <$0.50 are auto-claimed and skip this banner entirely
+                                        if (amountSponsored && typeof amountSponsored === 'number') {
+                                            if (transactionUsd > 0 && amountSponsored >= transactionUsd) {
+                                                return `This bill can be covered by Peanut! $${amountSponsored.toFixed(2)} back. Claim it now.`
                                             }
+                                            return `Peanut's got you! $${amountSponsored.toFixed(2)} back on this payment. Claim it now.`
                                         }
 
-                                        return amountSponsored && typeof amountSponsored === 'number'
-                                            ? `Get $${amountSponsored.toFixed(2)} back!`
-                                            : 'Claim it now to unlock your reward.'
+                                        // Fallback: no amount available yet
+                                        return 'You earned a Peanut Perk! Claim it now to unlock your reward.'
                                     })()}
                                 </p>
                             </div>
@@ -1278,17 +1285,22 @@ export default function QRPayPage() {
                                         const amountSponsored = qrPayment?.perk?.amountSponsored
                                         const transactionUsd =
                                             parseFloat(qrPayment?.details?.paymentAgainstAmount || '0') || 0
-                                        const percentage =
-                                            amountSponsored && transactionUsd > 0
-                                                ? Math.round((amountSponsored / transactionUsd) * 100)
-                                                : qrPayment?.perk?.discountPercentage || 100
-                                        if (percentage === 100) {
-                                            return 'We paid for this bill! Earn points, climb tiers and unlock even better perks.'
-                                        } else if (percentage > 100) {
-                                            return `We gave you ${percentage}% back — that's more than you paid! Earn points, climb tiers and unlock even better perks.`
-                                        } else {
-                                            return `We gave you ${percentage}% cashback! Earn points, climb tiers and unlock even better perks.`
+
+                                        // Tone scales with amount: small = growth nudge, large = celebratory
+                                        if (amountSponsored && typeof amountSponsored === 'number') {
+                                            if (transactionUsd > 0 && amountSponsored >= transactionUsd) {
+                                                return 'We paid for this bill! Earn points, climb tiers and unlock even better perks.'
+                                            }
+                                            if (amountSponsored < 0.5) {
+                                                return `You got $${amountSponsored.toFixed(2)} back. The more friends you invite, the more you earn!`
+                                            }
+                                            if (amountSponsored >= 5) {
+                                                return `We gave you $${amountSponsored.toFixed(2)} back! Your points are paying off.`
+                                            }
+                                            return `We gave you $${amountSponsored.toFixed(2)} back! Invite friends to unlock bigger rewards.`
                                         }
+
+                                        return 'We gave you cashback! Earn points, climb tiers and unlock even better perks.'
                                     })()}
                                 </p>
                             </div>

src/app/api/health/backend/route.ts

@@ -1,14 +1,21 @@
 import { NextResponse } from 'next/server'
-import { fetchWithSentry } from '@/utils/sentry.utils'
 import { PEANUT_API_URL } from '@/constants/general.consts'
 
 export const dynamic = 'force-dynamic'
 export const revalidate = 0
 export const fetchCache = 'force-no-store'
 
+const NO_CACHE_HEADERS = {
+    'Cache-Control': 'no-store, no-cache, must-revalidate, proxy-revalidate',
+    Pragma: 'no-cache',
+    Expires: '0',
+    'Surrogate-Control': 'no-store',
+}
+
 /**
- * Health check for Peanut API backend
- * Tests connectivity to the main peanut-api-ts backend service
+ * Health check for Peanut API backend.
+ * Uses the backend's dedicated /healthz endpoint (checks DB connectivity).
+ * Uses plain fetch to avoid health check errors polluting Sentry.
  */
 export async function GET() {
     const startTime = Date.now()
@@ -23,28 +30,26 @@ export async function GET() {
                     error: 'PEANUT_API_URL not configured',
                     responseTime: Date.now() - startTime,
                 },
-                { status: 500 }
+                { status: 500, headers: NO_CACHE_HEADERS }
             )
         }
 
-        // Test backend connectivity by fetching a specific user endpoint
         const backendTestStart = Date.now()
-        const backendResponse = await fetchWithSentry(`${PEANUT_API_URL}/users/username/hugo`, {
+        const backendResponse = await fetch(`${PEANUT_API_URL}/healthz`, {
             method: 'GET',
-            headers: {
-                'Content-Type': 'application/json',
-            },
+            headers: { 'Content-Type': 'application/json' },
             cache: 'no-store',
-            next: { revalidate: 0 },
+            signal: AbortSignal.timeout(8000),
         })
 
         const backendResponseTime = Date.now() - backendTestStart
 
-        // Backend is healthy if we get any response (200, 404, etc.) - what matters is connectivity
-        if (!backendResponse.ok && backendResponse.status >= 500) {
-            throw new Error(`Backend API returned server error ${backendResponse.status}`)
+        if (!backendResponse.ok) {
+            const errorData = await backendResponse.json().catch(() => null)
+            throw new Error(errorData?.error || `Backend /healthz returned ${backendResponse.status}`)
         }
 
+        const healthData = await backendResponse.json()
         const totalResponseTime = Date.now() - startTime
 
         return NextResponse.json(
@@ -54,29 +59,16 @@ export async function GET() {
                 timestamp: new Date().toISOString(),
                 responseTime: totalResponseTime,
                 details: {
-                    apiConnectivity: {
+                    healthz: {
                         status: 'healthy',
                         responseTime: backendResponseTime,
                         httpStatus: backendResponse.status,
                         apiUrl: PEANUT_API_URL,
-                        testEndpoint: '/users/username/hugo',
-                        message: backendResponse.ok
-                            ? 'Backend responding normally'
-                            : backendResponse.status === 404
-                              ? 'Backend accessible (user not found as expected)'
-                              : 'Backend accessible',
+                        dbConnected: healthData.dbConnected ?? true,
                     },
                 },
             },
-            {
-                status: 200,
-                headers: {
-                    'Cache-Control': 'no-store, no-cache, must-revalidate, proxy-revalidate',
-                    Pragma: 'no-cache',
-                    Expires: '0',
-                    'Surrogate-Control': 'no-store',
-                },
-            }
+            { status: 200, headers: NO_CACHE_HEADERS }
         )
     } catch (error) {
         const totalResponseTime = Date.now() - startTime
@@ -89,15 +81,7 @@ export async function GET() {
                 error: error instanceof Error ? error.message : 'Unknown error',
                 responseTime: totalResponseTime,
             },
-            {
-                status: 500,
-                headers: {
-                    'Cache-Control': 'no-store, no-cache, must-revalidate, proxy-revalidate',
-                    Pragma: 'no-cache',
-                    Expires: '0',
-                    'Surrogate-Control': 'no-store',
-                },
-            }
+            { status: 500, headers: NO_CACHE_HEADERS }
         )
     }
 }