Add frontend-optimized aggregation endpoints

- Add GET /mints/{mint_id}/profile - full mint profile in one request
- Add GET /mints/cards - lightweight cards for directory/grid views
- Add GET /mints/{mint_id}/metrics - timeseries metrics for charts
- Add GET /analytics/activity - ecosystem activity timeline
- Add POST /mints/compare - side-by-side mint comparison
- Add GET /mints/rankings - ranked leaderboards by trust/uptime/latency/reviews
- Add GET /mints/{mint_id}/similar - find similar mints
- Add GET /mints/recommended - use-case based recommendations
- Add GET /mints/{mint_id}/compatibility - wallet compatibility info
- Add GET /wallets/{wallet_name}/recommended-mints - wallet-specific recommendations
- Add GET /mints/{mint_id}/risk - risk assessment and flags
- Update OpenAPI documentation for all new endpoints
- Fix review rating parsing from content field
- Fix trust score calculation to include parsed ratings

src/docs/openapi.js

@@ -276,6 +276,62 @@ Admin endpoints require the \`X-Admin-Api-Key\` header. All admin actions are au
                 }
             }
         },
+        '/analytics/activity': {
+            get: {
+                tags: ['Analytics'],
+                summary: 'Ecosystem activity timeline',
+                description: 'Returns daily ecosystem activity: new mints, status changes, reviews posted, and metadata updates.',
+                operationId: 'getEcosystemActivity',
+                parameters: [{
+                    name: 'range',
+                    in: 'query',
+                    description: 'Time range for activity',
+                    schema: { type: 'string', enum: ['7d', '30d', '90d'], default: '30d' }
+                }],
+                responses: {
+                    200: {
+                        description: 'Ecosystem activity timeline',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/EcosystemActivityResponse' }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        '/wallets/{wallet_name}/recommended-mints': {
+            get: {
+                tags: ['Mints'],
+                summary: 'Get wallet-recommended mints',
+                description: 'Returns mints that are compatible with and recommended for a specific wallet based on required NUT support.',
+                operationId: 'getWalletRecommendedMints',
+                parameters: [{
+                        name: 'wallet_name',
+                        in: 'path',
+                        required: true,
+                        description: 'Wallet name (nutstash, minibits, enuts, cashu.me)',
+                        schema: { type: 'string' }
+                    },
+                    {
+                        name: 'limit',
+                        in: 'query',
+                        description: 'Maximum number of results',
+                        schema: { type: 'integer', default: 10, maximum: 50 }
+                    }
+                ],
+                responses: {
+                    200: {
+                        description: 'Wallet-compatible mints',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/WalletRecommendedMintsResponse' }
+                            }
+                        }
+                    }
+                }
+            }
+        },
         '/mints/trending': {
             get: {
                 tags: ['Mints'],
@@ -311,6 +367,168 @@ Admin endpoints require the \`X-Admin-Api-Key\` header. All admin actions are au
                 }
             }
         },
+        '/mints/cards': {
+            get: {
+                tags: ['Mints'],
+                summary: 'Get mint cards for lists',
+                description: 'Returns lightweight mint cards optimized for directory/grid views. Returns everything needed for a mint card in one request.',
+                operationId: 'getMintCards',
+                parameters: [{
+                        name: 'status',
+                        in: 'query',
+                        description: 'Filter by mint status',
+                        schema: { type: 'string', enum: ['online', 'degraded', 'offline'] }
+                    },
+                    {
+                        name: 'limit',
+                        in: 'query',
+                        description: 'Maximum number of results',
+                        schema: { type: 'integer', default: 100, maximum: 500 }
+                    },
+                    {
+                        name: 'offset',
+                        in: 'query',
+                        description: 'Number of results to skip',
+                        schema: { type: 'integer', default: 0 }
+                    },
+                    {
+                        name: 'sort_by',
+                        in: 'query',
+                        description: 'Sort field',
+                        schema: { type: 'string', enum: ['trust_score', 'uptime_30d', 'name', 'created_at'], default: 'trust_score' }
+                    },
+                    {
+                        name: 'sort_order',
+                        in: 'query',
+                        description: 'Sort order',
+                        schema: { type: 'string', enum: ['asc', 'desc'], default: 'desc' }
+                    }
+                ],
+                responses: {
+                    200: {
+                        description: 'Mint cards',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/MintCardsResponse' }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        '/mints/compare': {
+            post: {
+                tags: ['Mints'],
+                summary: 'Compare multiple mints',
+                description: 'Compare up to 10 mints side-by-side with uptime, latency, trust score, NUT support, reviews, and identity info.',
+                operationId: 'compareMints',
+                requestBody: {
+                    required: true,
+                    content: {
+                        'application/json': {
+                            schema: {
+                                type: 'object',
+                                required: ['mint_ids'],
+                                properties: {
+                                    mint_ids: {
+                                        type: 'array',
+                                        items: { type: 'string', format: 'uuid' },
+                                        maxItems: 10,
+                                        description: 'Array of mint IDs to compare'
+                                    }
+                                }
+                            }
+                        }
+                    }
+                },
+                responses: {
+                    200: {
+                        description: 'Mint comparison',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/MintComparisonResponse' }
+                            }
+                        }
+                    },
+                    400: {
+                        description: 'Invalid request',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/Error' }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        '/mints/rankings': {
+            get: {
+                tags: ['Mints'],
+                summary: 'Get mint rankings',
+                description: 'Get ranked leaderboard of mints by trust score, uptime, latency, or reviews.',
+                operationId: 'getMintRankings',
+                parameters: [{
+                        name: 'by',
+                        in: 'query',
+                        description: 'Ranking criteria',
+                        schema: { type: 'string', enum: ['trust', 'uptime', 'latency', 'reviews'], default: 'trust' }
+                    },
+                    {
+                        name: 'period',
+                        in: 'query',
+                        description: 'Time period for ranking',
+                        schema: { type: 'string', enum: ['7d', '30d', '90d'], default: '30d' }
+                    },
+                    {
+                        name: 'limit',
+                        in: 'query',
+                        description: 'Maximum number of results',
+                        schema: { type: 'integer', default: 50, maximum: 100 }
+                    }
+                ],
+                responses: {
+                    200: {
+                        description: 'Mint rankings',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/MintRankingsResponse' }
+                            }
+                        }
+                    }
+                }
+            }
+        },
+        '/mints/recommended': {
+            get: {
+                tags: ['Mints'],
+                summary: 'Get recommended mints',
+                description: 'Get mints recommended for specific use cases like mobile, high-volume, or privacy.',
+                operationId: 'getRecommendedMints',
+                parameters: [{
+                        name: 'use_case',
+                        in: 'query',
+                        description: 'Use case for recommendations',
+                        schema: { type: 'string', enum: ['general', 'mobile', 'high_volume', 'privacy'], default: 'general' }
+                    },
+                    {
+                        name: 'limit',
+                        in: 'query',
+                        description: 'Maximum number of results',
+                        schema: { type: 'integer', default: 10, maximum: 50 }
+                    }
+                ],
+                responses: {
+                    200: {
+                        description: 'Recommended mints',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/RecommendedMintsResponse' }
+                            }
+                        }
+                    }
+                }
+            }
+        },
         '/mints': {
             get: {
                 tags: ['Mints'],
@@ -719,6 +937,128 @@ Admin endpoints require the \`X-Admin-Api-Key\` header. All admin actions are au
                 }
             }
         },
+        '/mints/{mint_id}/profile': {
+            get: {
+                tags: ['Mint Details'],
+                summary: 'Get full mint profile',
+                description: 'Returns all mint information in one request: basic info, status, uptime summary (24h/7d/30d), trust score with breakdown, supported NUTs, metadata, review summary, and popularity metrics.',
+                operationId: 'getMintProfile',
+                parameters: [
+                    { $ref: '#/components/parameters/mintId' }
+                ],
+                responses: {
+                    200: {
+                        description: 'Full mint profile',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/MintProfileResponse' }
+                            }
+                        }
+                    },
+                    404: { $ref: '#/components/responses/NotFound' }
+                }
+            }
+        },
+        '/mints/{mint_id}/metrics': {
+            get: {
+                tags: ['Analytics'],
+                summary: 'Get mint metrics timeseries',
+                description: 'Returns time-bucketed metrics for charts: uptime %, latency avg, failures, reviews, views, and metadata changes over time.',
+                operationId: 'getMintMetrics',
+                parameters: [
+                    { $ref: '#/components/parameters/mintId' },
+                    {
+                        name: 'range',
+                        in: 'query',
+                        description: 'Time range for metrics',
+                        schema: { type: 'string', enum: ['7d', '30d', '90d'], default: '7d' }
+                    }
+                ],
+                responses: {
+                    200: {
+                        description: 'Mint metrics timeseries',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/MintMetricsResponse' }
+                            }
+                        }
+                    },
+                    404: { $ref: '#/components/responses/NotFound' }
+                }
+            }
+        },
+        '/mints/{mint_id}/similar': {
+            get: {
+                tags: ['Mints'],
+                summary: 'Get similar mints',
+                description: 'Find mints similar to this one based on NUT support, uptime profile, and trust score.',
+                operationId: 'getSimilarMints',
+                parameters: [
+                    { $ref: '#/components/parameters/mintId' },
+                    {
+                        name: 'limit',
+                        in: 'query',
+                        description: 'Maximum number of results',
+                        schema: { type: 'integer', default: 5, maximum: 20 }
+                    }
+                ],
+                responses: {
+                    200: {
+                        description: 'Similar mints',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/SimilarMintsResponse' }
+                            }
+                        }
+                    },
+                    404: { $ref: '#/components/responses/NotFound' }
+                }
+            }
+        },
+        '/mints/{mint_id}/compatibility': {
+            get: {
+                tags: ['Mint Details'],
+                summary: 'Get wallet compatibility',
+                description: 'Returns supported NUTs, known compatible/incompatible wallets, and known issues.',
+                operationId: 'getMintCompatibility',
+                parameters: [
+                    { $ref: '#/components/parameters/mintId' }
+                ],
+                responses: {
+                    200: {
+                        description: 'Compatibility info',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/MintCompatibilityResponse' }
+                            }
+                        }
+                    },
+                    404: { $ref: '#/components/responses/NotFound' }
+                }
+            }
+        },
+        '/mints/{mint_id}/risk': {
+            get: {
+                tags: ['Trust'],
+                summary: 'Get risk assessment',
+                description: 'Returns risk flags and indicators: uptime volatility, metadata churn, review anomalies, centralization risk.',
+                operationId: 'getMintRisk',
+                parameters: [
+                    { $ref: '#/components/parameters/mintId' }
+                ],
+                responses: {
+                    200: {
+                        description: 'Risk assessment',
+                        content: {
+                            'application/json': {
+                                schema: { $ref: '#/components/schemas/MintRiskResponse' }
+                            }
+                        }
+                    },
+                    404: { $ref: '#/components/responses/NotFound' }
+                }
+            }
+        },
         '/mints/{mint_id}/features': {
             get: {
                 tags: ['Mint Details'],
@@ -2307,6 +2647,360 @@ Admin endpoints require the \`X-Admin-Api-Key\` header. All admin actions are au
                     visibility: { type: 'string', enum: ['public', 'hidden'] },
                     status: { type: 'string' }
                 }
+            },
+            MintCardsResponse: {
+                type: 'object',
+                properties: {
+                    cards: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                mint_id: { type: 'string', format: 'uuid' },
+                                name: { type: 'string', nullable: true },
+                                url: { type: 'string' },
+                                icon_url: { type: 'string', nullable: true },
+                                status: { type: 'string' },
+                                trust_score: { type: 'integer', nullable: true },
+                                trust_level: { type: 'string', nullable: true },
+                                uptime_pct: { type: 'number', nullable: true },
+                                review_count: { type: 'integer' },
+                                nut_count: { type: 'integer' },
+                                has_tor: { type: 'boolean' }
+                            }
+                        }
+                    },
+                    total: { type: 'integer' },
+                    limit: { type: 'integer' },
+                    offset: { type: 'integer' }
+                }
+            },
+            MintComparisonResponse: {
+                type: 'object',
+                properties: {
+                    mints: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                mint_id: { type: 'string', format: 'uuid' },
+                                name: { type: 'string', nullable: true },
+                                url: { type: 'string' },
+                                icon_url: { type: 'string', nullable: true },
+                                status: { type: 'string' },
+                                trust: {
+                                    type: 'object',
+                                    properties: {
+                                        score: { type: 'integer', nullable: true },
+                                        level: { type: 'string', nullable: true },
+                                        breakdown: { type: 'object', nullable: true }
+                                    }
+                                },
+                                uptime: {
+                                    type: 'object',
+                                    properties: {
+                                        pct_30d: { type: 'number', nullable: true },
+                                        avg_rtt_ms: { type: 'integer', nullable: true }
+                                    }
+                                },
+                                nuts: { type: 'array', items: { type: 'integer' } },
+                                reviews: {
+                                    type: 'object',
+                                    properties: {
+                                        count: { type: 'integer' },
+                                        avg_rating: { type: 'number', nullable: true }
+                                    }
+                                },
+                                identity: {
+                                    type: 'object',
+                                    properties: {
+                                        has_pubkey: { type: 'boolean' }
+                                    }
+                                }
+                            }
+                        }
+                    },
+                    computed_at: { type: 'string', format: 'date-time' }
+                }
+            },
+            MintRankingsResponse: {
+                type: 'object',
+                properties: {
+                    ranking_by: { type: 'string', enum: ['trust', 'uptime', 'latency', 'reviews'] },
+                    period: { type: 'string' },
+                    mints: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                rank: { type: 'integer' },
+                                mint_id: { type: 'string', format: 'uuid' },
+                                name: { type: 'string', nullable: true },
+                                url: { type: 'string' },
+                                icon_url: { type: 'string', nullable: true },
+                                status: { type: 'string' },
+                                score: { type: 'number', description: 'Score for the ranking criteria' },
+                                trust_score: { type: 'integer', nullable: true }
+                            }
+                        }
+                    },
+                    computed_at: { type: 'string', format: 'date-time' }
+                }
+            },
+            RecommendedMintsResponse: {
+                type: 'object',
+                properties: {
+                    use_case: { type: 'string', enum: ['general', 'mobile', 'high_volume', 'privacy'] },
+                    mints: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                mint_id: { type: 'string', format: 'uuid' },
+                                name: { type: 'string', nullable: true },
+                                url: { type: 'string' },
+                                icon_url: { type: 'string', nullable: true },
+                                status: { type: 'string' },
+                                trust_score: { type: 'integer', nullable: true },
+                                trust_level: { type: 'string', nullable: true },
+                                uptime_pct: { type: 'number', nullable: true }
+                            }
+                        }
+                    },
+                    computed_at: { type: 'string', format: 'date-time' }
+                }
+            },
+            MintProfileResponse: {
+                type: 'object',
+                properties: {
+                    mint_id: { type: 'string', format: 'uuid' },
+                    canonical_url: { type: 'string' },
+                    urls: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                url: { type: 'string' },
+                                type: { type: 'string' },
+                                active: { type: 'boolean' }
+                            }
+                        }
+                    },
+                    name: { type: 'string', nullable: true },
+                    icon_url: { type: 'string', nullable: true },
+                    status: { type: 'string' },
+                    offline_since: { type: 'string', format: 'date-time', nullable: true },
+                    created_at: { type: 'string', format: 'date-time' },
+                    uptime: {
+                        type: 'object',
+                        properties: {
+                            '24h': {
+                                type: 'object',
+                                nullable: true,
+                                properties: {
+                                    uptime_pct: { type: 'number' },
+                                    avg_rtt_ms: { type: 'integer' },
+                                    checks: { type: 'integer' }
+                                }
+                            },
+                            '7d': {
+                                type: 'object',
+                                nullable: true,
+                                properties: {
+                                    uptime_pct: { type: 'number' },
+                                    avg_rtt_ms: { type: 'integer' },
+                                    checks: { type: 'integer' }
+                                }
+                            },
+                            '30d': {
+                                type: 'object',
+                                nullable: true,
+                                properties: {
+                                    uptime_pct: { type: 'number' },
+                                    avg_rtt_ms: { type: 'integer' },
+                                    checks: { type: 'integer' }
+                                }
+                            }
+                        }
+                    },
+                    trust: {
+                        type: 'object',
+                        properties: {
+                            score: { type: 'integer', nullable: true },
+                            level: { type: 'string' },
+                            breakdown: { type: 'object', nullable: true },
+                            computed_at: { type: 'string', format: 'date-time', nullable: true }
+                        }
+                    },
+                    metadata: {
+                        type: 'object',
+                        nullable: true,
+                        properties: {
+                            name: { type: 'string', nullable: true },
+                            pubkey: { type: 'string', nullable: true },
+                            version: { type: 'string', nullable: true },
+                            description: { type: 'string', nullable: true },
+                            description_long: { type: 'string', nullable: true },
+                            contact: { type: 'array', nullable: true },
+                            motd: { type: 'string', nullable: true },
+                            tos_url: { type: 'string', nullable: true },
+                            last_fetched_at: { type: 'string', format: 'date-time' }
+                        }
+                    },
+                    supported_nuts: { type: 'array', items: { type: 'integer' } },
+                    reviews: {
+                        type: 'object',
+                        properties: {
+                            total: { type: 'integer' },
+                            unique_reviewers: { type: 'integer' },
+                            avg_rating: { type: 'number', nullable: true }
+                        }
+                    },
+                    popularity: {
+                        type: 'object',
+                        properties: {
+                            views_24h: { type: 'integer' },
+                            views_7d: { type: 'integer' },
+                            views_30d: { type: 'integer' },
+                            source: { type: 'string' },
+                            incidents_7d: { type: 'integer' },
+                            incidents_30d: { type: 'integer' }
+                        }
+                    },
+                    computed_at: { type: 'string', format: 'date-time' }
+                }
+            },
+            MintMetricsResponse: {
+                type: 'object',
+                properties: {
+                    range: { type: 'string' },
+                    data: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                date: { type: 'string', format: 'date' },
+                                uptime_pct: { type: 'number', nullable: true },
+                                avg_rtt_ms: { type: 'integer', nullable: true },
+                                failures: { type: 'integer' },
+                                reviews: { type: 'integer' },
+                                views: { type: 'integer' },
+                                metadata_changes: { type: 'integer' }
+                            }
+                        }
+                    },
+                    computed_at: { type: 'string', format: 'date-time' }
+                }
+            },
+            SimilarMintsResponse: {
+                type: 'object',
+                properties: {
+                    mints: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                mint_id: { type: 'string', format: 'uuid' },
+                                name: { type: 'string', nullable: true },
+                                url: { type: 'string' },
+                                icon_url: { type: 'string', nullable: true },
+                                status: { type: 'string' },
+                                trust_score: { type: 'integer', nullable: true },
+                                trust_level: { type: 'string', nullable: true },
+                                similarity_score: { type: 'integer', description: 'Similarity score 0-100' }
+                            }
+                        }
+                    },
+                    computed_at: { type: 'string', format: 'date-time' }
+                }
+            },
+            MintCompatibilityResponse: {
+                type: 'object',
+                properties: {
+                    supported_nuts: { type: 'array', items: { type: 'integer' } },
+                    version: { type: 'string', nullable: true },
+                    compatible_wallets: { type: 'array', items: { type: 'string' } },
+                    incompatible_wallets: { type: 'array', items: { type: 'string' } },
+                    known_issues: { type: 'array', items: { type: 'string' } },
+                    recommendations: { type: 'array', items: { type: 'string' } },
+                    computed_at: { type: 'string', format: 'date-time' }
+                }
+            },
+            MintRiskResponse: {
+                type: 'object',
+                properties: {
+                    mint_id: { type: 'string', format: 'uuid' },
+                    risk_level: { type: 'string', enum: ['low', 'medium', 'high'] },
+                    risk_score: { type: 'integer', minimum: 0, maximum: 100 },
+                    flags: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                type: { type: 'string' },
+                                severity: { type: 'string', enum: ['low', 'medium', 'high'] },
+                                message: { type: 'string' }
+                            }
+                        }
+                    },
+                    summary: {
+                        type: 'object',
+                        properties: {
+                            uptime_volatile: { type: 'boolean' },
+                            metadata_churn: { type: 'boolean' },
+                            centralization_risk: { type: 'boolean' },
+                            review_anomalies: { type: 'boolean' }
+                        }
+                    },
+                    computed_at: { type: 'string', format: 'date-time' }
+                }
+            },
+            EcosystemActivityResponse: {
+                type: 'object',
+                properties: {
+                    range: { type: 'string' },
+                    data: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                date: { type: 'string', format: 'date' },
+                                new_mints: { type: 'integer' },
+                                mints_offline: { type: 'integer' },
+                                mints_online: { type: 'integer' },
+                                reviews: { type: 'integer' },
+                                metadata_updates: { type: 'integer' }
+                            }
+                        }
+                    },
+                    computed_at: { type: 'string', format: 'date-time' }
+                }
+            },
+            WalletRecommendedMintsResponse: {
+                type: 'object',
+                properties: {
+                    wallet: { type: 'string' },
+                    required_nuts: { type: 'array', items: { type: 'integer' } },
+                    preferred_nuts: { type: 'array', items: { type: 'integer' } },
+                    mints: {
+                        type: 'array',
+                        items: {
+                            type: 'object',
+                            properties: {
+                                mint_id: { type: 'string', format: 'uuid' },
+                                name: { type: 'string', nullable: true },
+                                url: { type: 'string' },
+                                icon_url: { type: 'string', nullable: true },
+                                status: { type: 'string' },
+                                trust_score: { type: 'integer', nullable: true },
+                                trust_level: { type: 'string', nullable: true },
+                                uptime_pct: { type: 'number', nullable: true },
+                                compatibility_score: { type: 'integer', description: 'Compatibility score' }
+                            }
+                        }
+                    },
+                    computed_at: { type: 'string', format: 'date-time' }
+                }
             }
         }
     }

src/routes/mints.js

@@ -32,7 +32,17 @@ import {
     getPopularMints,
     getMintStats,
     getMintAvailability,
-    getMintCard
+    getMintCard,
+    getMintProfile,
+    getMintCards,
+    getMintMetrics,
+    compareMints,
+    getMintRankings,
+    getSimilarMints,
+    getRecommendedMints,
+    getMintCompatibility,
+    getWalletRecommendedMints,
+    getMintRisk
 } from '../services/AnalyticsService.js';
 
 const router = Router();
@@ -249,6 +259,103 @@ router.get('/trending', async(req, res) => {
     }
 });
 
+/**
+ * GET /mints/cards
+ * Get lightweight mint cards for directory/list views
+ */
+router.get('/cards', (req, res) => {
+    try {
+        const { status, limit = 100, offset = 0, sort_by = 'trust_score', sort_order = 'desc' } = req.query;
+
+        const cards = getMintCards({
+            status,
+            limit: Math.min(parseInt(limit) || 100, 500),
+            offset: parseInt(offset) || 0,
+            sortBy: sort_by,
+            sortOrder: sort_order
+        });
+
+        res.json({
+            cards,
+            total: cards.length,
+            limit: Math.min(parseInt(limit) || 100, 500),
+            offset: parseInt(offset) || 0
+        });
+    } catch (error) {
+        console.error('[API] Error getting mint cards:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+/**
+ * POST /mints/compare
+ * Compare multiple mints side by side
+ */
+router.post('/compare', (req, res) => {
+    try {
+        const { mint_ids } = req.body;
+
+        if (!mint_ids || !Array.isArray(mint_ids) || mint_ids.length === 0) {
+            return res.status(400).json({ error: 'mint_ids array required' });
+        }
+
+        if (mint_ids.length > 10) {
+            return res.status(400).json({ error: 'Maximum 10 mints can be compared' });
+        }
+
+        const comparison = compareMints(mint_ids);
+        res.json(comparison);
+    } catch (error) {
+        console.error('[API] Error comparing mints:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+/**
+ * GET /mints/rankings
+ * Get ranked mint leaderboard
+ */
+router.get('/rankings', (req, res) => {
+    try {
+        const { by = 'trust', period = '30d', limit = 50 } = req.query;
+
+        const validBy = ['trust', 'uptime', 'latency', 'reviews'];
+        const validPeriods = ['7d', '30d', '90d'];
+
+        const rankings = getMintRankings(
+            validBy.includes(by) ? by : 'trust',
+            validPeriods.includes(period) ? period : '30d',
+            Math.min(parseInt(limit) || 50, 100)
+        );
+
+        res.json(rankings);
+    } catch (error) {
+        console.error('[API] Error getting rankings:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+/**
+ * GET /mints/recommended
+ * Get recommended mints by use case
+ */
+router.get('/recommended', (req, res) => {
+    try {
+        const { use_case = 'general', limit = 10 } = req.query;
+
+        const validUseCases = ['general', 'mobile', 'high_volume', 'privacy'];
+        const recommendations = getRecommendedMints(
+            validUseCases.includes(use_case) ? use_case : 'general',
+            Math.min(parseInt(limit) || 10, 50)
+        );
+
+        res.json(recommendations);
+    } catch (error) {
+        console.error('[API] Error getting recommendations:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
 // ==========================================
 // BY-URL ROUTES (must come BEFORE :mint_id routes)
 // ==========================================
@@ -906,4 +1013,93 @@ router.get('/:mint_id/card', resolveMintMiddleware, (req, res) => {
     }
 });
 
+/**
+ * GET /mints/:mint_id/profile
+ * Full mint profile - aggregated data in one request
+ */
+router.get('/:mint_id/profile', resolveMintMiddleware, async(req, res) => {
+    try {
+        const profile = await getMintProfile(req.mint.mint_id);
+        if (!profile) {
+            return res.status(404).json({ error: 'Mint not found' });
+        }
+
+        // Record pageview
+        recordPageview(req.mint.mint_id, {
+            sessionId: req.headers['x-session-id'],
+            userAgent: req.headers['user-agent'],
+            referer: req.headers['referer']
+        });
+
+        res.json(profile);
+    } catch (error) {
+        console.error('[API] Error getting mint profile:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+/**
+ * GET /mints/:mint_id/metrics
+ * Mint metrics timeseries for charts
+ */
+router.get('/:mint_id/metrics', resolveMintMiddleware, (req, res) => {
+    try {
+        const { range = '7d' } = req.query;
+        const validRanges = ['7d', '30d', '90d'];
+        const timeRange = validRanges.includes(range) ? range : '7d';
+
+        const metrics = getMintMetrics(req.mint.mint_id, timeRange);
+        res.json(metrics);
+    } catch (error) {
+        console.error('[API] Error getting mint metrics:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+/**
+ * GET /mints/:mint_id/similar
+ * Find similar mints
+ */
+router.get('/:mint_id/similar', resolveMintMiddleware, (req, res) => {
+    try {
+        const { limit = 5 } = req.query;
+        const similar = getSimilarMints(
+            req.mint.mint_id,
+            Math.min(parseInt(limit) || 5, 20)
+        );
+        res.json(similar);
+    } catch (error) {
+        console.error('[API] Error getting similar mints:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+/**
+ * GET /mints/:mint_id/compatibility
+ * Wallet compatibility info
+ */
+router.get('/:mint_id/compatibility', resolveMintMiddleware, (req, res) => {
+    try {
+        const compatibility = getMintCompatibility(req.mint.mint_id);
+        res.json(compatibility);
+    } catch (error) {
+        console.error('[API] Error getting compatibility:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+/**
+ * GET /mints/:mint_id/risk
+ * Risk assessment and flags
+ */
+router.get('/:mint_id/risk', resolveMintMiddleware, (req, res) => {
+    try {
+        const risk = getMintRisk(req.mint.mint_id);
+        res.json(risk);
+    } catch (error) {
+        console.error('[API] Error getting risk assessment:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
 export default router;

src/routes/system.js

@@ -16,7 +16,9 @@ import {
     getNutsAnalytics,
     getStatusDistribution,
     getNetworkBreakdown,
-    getMetadataQuality
+    getMetadataQuality,
+    getEcosystemActivity,
+    getWalletRecommendedMints
 } from '../services/AnalyticsService.js';
 import { getRecentEcosystemReviews } from '../services/ReviewService.js';
 import { nowISO } from '../utils/time.js';
@@ -359,4 +361,51 @@ router.get('/reviews/recent', (req, res) => {
     }
 });
 
+/**
+ * GET /analytics/activity
+ * Ecosystem-wide activity timeline
+ */
+router.get('/analytics/activity', (req, res) => {
+    try {
+        const { range = '30d' } = req.query;
+        const validRanges = ['7d', '30d', '90d'];
+        const timeRange = validRanges.includes(range) ? range : '30d';
+
+        const activity = getEcosystemActivity(timeRange);
+        res.json(activity);
+    } catch (error) {
+        console.error('[API] Error getting ecosystem activity:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
+// ==========================================
+// WALLET INTEGRATION
+// ==========================================
+
+/**
+ * GET /wallets/:wallet_name/recommended-mints
+ * Get recommended mints for a specific wallet
+ */
+router.get('/wallets/:wallet_name/recommended-mints', (req, res) => {
+    try {
+        const { wallet_name } = req.params;
+        const { limit = 10 } = req.query;
+
+        if (!wallet_name) {
+            return res.status(400).json({ error: 'Wallet name required' });
+        }
+
+        const recommendations = getWalletRecommendedMints(
+            wallet_name,
+            Math.min(parseInt(limit) || 10, 50)
+        );
+
+        res.json(recommendations);
+    } catch (error) {
+        console.error('[API] Error getting wallet recommendations:', error);
+        res.status(500).json({ error: 'Internal server error' });
+    }
+});
+
 export default router;

src/services/ReviewService.js

@@ -94,6 +94,33 @@ export function processReviewEvent(event) {
     });
 }
 
+/**
+ * Parse rating from content text (e.g., "[5/5]", "(4/5)", etc.)
+ * Returns rating 1-5 or null if not found
+ */
+function parseRatingFromContent(content) {
+    if (!content) return null;
+    
+    // Match patterns like [5/5], (4/5), [3/5], etc.
+    const match = content.match(/[\[\(](\d)\/(\d)[\]\)]/);
+    if (match) {
+        const numerator = parseInt(match[1], 10);
+        const denominator = parseInt(match[2], 10);
+        if (!isNaN(numerator) && !isNaN(denominator) && denominator > 0) {
+            // Convert to 1-5 scale based on numerator/denominator ratio
+            // e.g., 5/5 = 5, 4/5 = 4, 3/5 = 3, etc.
+            if (denominator === 5 && numerator >= 1 && numerator <= 5) {
+                return numerator;
+            }
+            // Handle other formats like 1/1 = 5, 0/1 = 1
+            if (denominator === 1) {
+                return numerator > 0 ? 5 : 1;
+            }
+        }
+    }
+    return null;
+}
+
 /**
  * Parse review data from Nostr event (NIP-87)
  * 
@@ -154,6 +181,11 @@ function parseReviewEvent(event) {
     // Content (review text)
     const content = event.content ? event.content.trim() : null;
 
+    // Parse rating from content if not found in tags
+    if (rating === null && content) {
+        rating = parseRatingFromContent(content);
+    }
+
     if (!mintUrl && !content) {
         return null; // Not a useful review
     }
@@ -205,11 +237,20 @@ export function getReviews(mintId, options = {}) {
 
     const reviews = query(sql, params);
 
-    // Convert Unix timestamp to ISO
+    // Convert Unix timestamp to ISO and parse rating from content if needed
-    return reviews.map(r => ({
+    return reviews.map(r => {
-        ...r,
+        // Parse rating from content if rating column is null
-        created_at: unixToISO(r.created_at)
+        let rating = r.rating;
-    }));
+        if (rating === null && r.content) {
+            rating = parseRatingFromContent(r.content);
+        }
+        
+        return {
+            ...r,
+            rating,
+            created_at: unixToISO(r.created_at)
+        };
+    });
 }
 
 /**
@@ -232,11 +273,11 @@ export function getReviewStats(mintId) {
         pubkey,
         CASE 
           WHEN rating IS NOT NULL THEN rating
-          WHEN content LIKE '[5/5]%' OR content LIKE '%(5/5)%' THEN 5
+          WHEN content LIKE '%[5/5]%' OR content LIKE '%(5/5)%' THEN 5
-          WHEN content LIKE '[4/5]%' OR content LIKE '%(4/5)%' THEN 4
+          WHEN content LIKE '%[4/5]%' OR content LIKE '%(4/5)%' THEN 4
-          WHEN content LIKE '[3/5]%' OR content LIKE '%(3/5)%' THEN 3
+          WHEN content LIKE '%[3/5]%' OR content LIKE '%(3/5)%' THEN 3
-          WHEN content LIKE '[2/5]%' OR content LIKE '%(2/5)%' THEN 2
+          WHEN content LIKE '%[2/5]%' OR content LIKE '%(2/5)%' THEN 2
-          WHEN content LIKE '[1/5]%' OR content LIKE '%(1/5)%' THEN 1
+          WHEN content LIKE '%[1/5]%' OR content LIKE '%(1/5)%' THEN 1
           ELSE NULL
         END as parsed_rating
       FROM reviews
@@ -311,10 +352,19 @@ export function getRecentReviews(limit = 20) {
     LIMIT ?
   `, [limit]);
 
-    return reviews.map(r => ({
+    return reviews.map(r => {
-        ...r,
+        // Parse rating from content if rating column is null
-        created_at: unixToISO(r.created_at)
+        let rating = r.rating;
-    }));
+        if (rating === null && r.content) {
+            rating = parseRatingFromContent(r.content);
+        }
+        
+        return {
+            ...r,
+            rating,
+            created_at: unixToISO(r.created_at)
+        };
+    });
 }
 
 /**
@@ -359,10 +409,19 @@ export function getAllReviews(options = {}) {
 
     const reviews = query(sql, params);
 
-    return reviews.map(r => ({
+    return reviews.map(r => {
-        ...r,
+        // Parse rating from content if rating column is null
-        created_at: unixToISO(r.created_at)
+        let rating = r.rating;
-    }));
+        if (rating === null && r.content) {
+            rating = parseRatingFromContent(r.content);
+        }
+        
+        return {
+            ...r,
+            rating,
+            created_at: unixToISO(r.created_at)
+        };
+    });
 }
 
 /**
@@ -429,11 +488,11 @@ export function getReviewSummary(mintId) {
         FROM (
             SELECT CASE 
                 WHEN rating IS NOT NULL THEN rating
-                WHEN content LIKE '[5/5]%' OR content LIKE '%(5/5)%' THEN 5
+                WHEN content LIKE '%[5/5]%' OR content LIKE '%(5/5)%' THEN 5
-                WHEN content LIKE '[4/5]%' OR content LIKE '%(4/5)%' THEN 4
+                WHEN content LIKE '%[4/5]%' OR content LIKE '%(4/5)%' THEN 4
-                WHEN content LIKE '[3/5]%' OR content LIKE '%(3/5)%' THEN 3
+                WHEN content LIKE '%[3/5]%' OR content LIKE '%(3/5)%' THEN 3
-                WHEN content LIKE '[2/5]%' OR content LIKE '%(2/5)%' THEN 2
+                WHEN content LIKE '%[2/5]%' OR content LIKE '%(2/5)%' THEN 2
-                WHEN content LIKE '[1/5]%' OR content LIKE '%(1/5)%' THEN 1
+                WHEN content LIKE '%[1/5]%' OR content LIKE '%(1/5)%' THEN 1
                 ELSE NULL
             END as parsed_rating
             FROM reviews
@@ -469,6 +528,7 @@ export function getRecentEcosystemReviews(limit = 20, since = null) {
             m.canonical_url as mint_url,
             r.pubkey,
             r.rating,
+            r.content,
             SUBSTR(r.content, 1, 200) as excerpt,
             r.created_at
         FROM reviews r
@@ -487,9 +547,18 @@ export function getRecentEcosystemReviews(limit = 20, since = null) {
 
     const reviews = query(sql, params);
 
-    return reviews.map(r => ({
+    return reviews.map(r => {
-        ...r,
+        // Parse rating from content if rating column is null
-        created_at: unixToISO(r.created_at),
+        let rating = r.rating;
-        excerpt: r.excerpt ? (r.excerpt.length >= 200 ? r.excerpt + '...' : r.excerpt) : null
+        if (rating === null && r.content) {
-    }));
+            rating = parseRatingFromContent(r.content);
+        }
+        
+        return {
+            ...r,
+            rating,
+            created_at: unixToISO(r.created_at),
+            excerpt: r.excerpt ? (r.excerpt.length >= 200 ? r.excerpt + '...' : r.excerpt) : null
+        };
+    });
 }

src/services/TrustService.js

@@ -29,18 +29,23 @@ export function calculateTrustScore(mintId) {
 
     // Calculate uptime component (max 40 points)
     const uptimeScore = calculateUptimeScore(mintId, breakdown.uptime);
+    breakdown.uptime.score = Math.round(uptimeScore * 10) / 10;
 
     // Calculate speed component (max 25 points)
     const speedScore = calculateSpeedScore(mintId, breakdown.speed);
+    breakdown.speed.score = Math.round(speedScore * 10) / 10;
 
     // Calculate reviews component (max 20 points)
     const reviewsScore = calculateReviewsScore(mintId, breakdown.reviews);
+    breakdown.reviews.score = Math.round(reviewsScore * 10) / 10;
 
     // Calculate identity component (max 10 points)
     const identityScore = calculateIdentityScore(mintId, breakdown.identity);
+    breakdown.identity.score = Math.round(identityScore * 10) / 10;
 
     // Calculate penalties (up to -15 points)
     const penalties = calculatePenalties(mintId, breakdown.penalties);
+    breakdown.penalties.score = Math.round(penalties * 10) / 10;
 
     // Total score (clamped 0-100)
     const totalScore = Math.max(0, Math.min(100,
@@ -149,11 +154,11 @@ function calculateReviewsScore(mintId, component) {
       COUNT(*) as count,
       AVG(CASE 
         WHEN rating IS NOT NULL THEN rating
-        WHEN content LIKE '[5/5]%' OR content LIKE '%(5/5)%' THEN 5
+        WHEN content LIKE '%[5/5]%' OR content LIKE '%(5/5)%' THEN 5
-        WHEN content LIKE '[4/5]%' OR content LIKE '%(4/5)%' THEN 4
+        WHEN content LIKE '%[4/5]%' OR content LIKE '%(4/5)%' THEN 4
-        WHEN content LIKE '[3/5]%' OR content LIKE '%(3/5)%' THEN 3
+        WHEN content LIKE '%[3/5]%' OR content LIKE '%(3/5)%' THEN 3
-        WHEN content LIKE '[2/5]%' OR content LIKE '%(2/5)%' THEN 2
+        WHEN content LIKE '%[2/5]%' OR content LIKE '%(2/5)%' THEN 2
-        WHEN content LIKE '[1/5]%' OR content LIKE '%(1/5)%' THEN 1
+        WHEN content LIKE '%[1/5]%' OR content LIKE '%(1/5)%' THEN 1
         ELSE NULL
       END) as avg_rating,
       COUNT(DISTINCT pubkey) as unique_reviewers