This mobile blockchain app provides real-time onchain monitoring with crypto push notifications and wallet tracking. Imagine needing instant blockchain transaction monitoring for OTC trades: a large USDT transfer arrives and you must know immediately. Dozens of wallets, hundreds of transactions per day make manual block explorer checks impractical. We build web3 mobile apps that solve this: subscribing to on-chain events via WebSocket, filtering by amount and type, and pushing alerts in 1-2 seconds. Such a system saves hours of manual work and reduces the risk of missing a large trade.
Over the past five years, we have delivered more than 15 projects for DeFi protocols and crypto funds, including a stablecoin monitoring solution with threshold filtering. Each app undergoes load testing at 1000+ notifications per minute and a security audit. The result: stable operation under high load and guaranteed delivery.
How transaction monitoring works
There are four main approaches; the choice depends on speed, load, and complexity requirements.
| Method | Latency | RPC Load | Reliability |
|---|---|---|---|
| HTTP Polling | 10-30 s | High | Low |
| WebSocket RPC | 1-3 s | Medium | High |
| Webhooks (Alchemy/QuickNode) | 1-2 s | Low | Very High |
| Blockchain indexer (The Graph) | 5-15 s | Low | Medium |
WebSocket via Infura gives 1-2 second latency — 30x faster than HTTP polling. For a mobile app with push notifications, the third option is optimal: Alchemy Notify → backend webhook → FCM/APNs → phone.
Why transaction filtering is critical
Notifying on every transaction is overwhelming for active addresses (whale wallets do hundreds of transactions per day). Filters are needed for effective crypto tracking:
- Minimum amount (e.g., only notify if > $500)
- Event type (only incoming, or only DEX swap)
- Quiet hours: batch notifications between 23:00–08:00, show a single summary push in the morning
On iOS, customize notifications via UNNotificationContent with UNNotificationServiceExtension — you can enrich push data before displaying. On Android, use NotificationCompat.Builder with InboxStyle for batching. Such filtering significantly saves bandwidth and battery, and reduces server load.
Supported blockchains
Different chains mean different RPCs, address formats, and token standards. This multi-chain app supports both EVM and Solana monitoring. Ethereum and EVM-compatible (Polygon, BSC, Arbitrum, Base) — one adapter with different RPC URL and chain ID. Solana — separate SDK, base58 addresses, tokens via SPL.
Each chain gets its own adapter:
interface ChainMonitor { val chainId: Int suspend fun subscribeToAddress(address: String, listener: TxEventListener) suspend fun unsubscribe(address: String) suspend fun getRecentTransactions(address: String, limit: Int): List<Transaction> } class EthereumMonitor(private val alchemyWsUrl: String) : ChainMonitor { override val chainId = 1 // ... } class SolanaMonitor(private val heliusApiKey: String) : ChainMonitor { override val chainId = 101 // Solana mainnet // ... } RPC provider comparison for push notifications
| Provider | WebSocket | Webhooks | Free Tier | Latency |
|---|---|---|---|---|
| Alchemy | Yes | Yes | 300M compute units/month | 1-2 s |
| QuickNode | Yes | Yes | 100M compute units/month | 1-2 s |
| Infura | Yes | No | 100K requests/day | 1-3 s |
| Moralis | No | Yes | 40K requests/day | 2-5 s |
For a mobile push app, we recommend Alchemy or QuickNode due to low latency and built-in webhook support. Provider choice impacts budget: Alchemy and QuickNode are more expensive than Infura but offer lower latency and built-in webhooks, which saves development time.
Application architecture
Application Architecture Details
Main screen — chronological feed of all tracked events. Filters: by chain, by address, by event type. Search by tx hash. Tap — detailed card with link to block explorer. Data loads from our own backend, which stores event history (because the blockchain doesn't provide a convenient "give me events for this address over the last month" without an archive node). Pagination is cursor-based.
struct FilterConfig: Codable { var minAmountUSD: Double var eventTypes: [EventType] var quietHoursStart: Date? var quietHoursEnd: Date? } enum EventType: String, Codable { case incoming, outgoing, swap, contractInteraction } Monitoring setup process
- Step 1: Requirements gathering — identify chains, addresses, filters, and notification scenarios.
- Step 2: RPC provider selection — Alchemy, QuickNode, or Infura based on budget and load.
- Step 3: Adapter development — build modules for each chain with WebSocket and webhook support.
- Step 4: Filter configuration — set thresholds, quiet hours, and batching.
- Step 5: Backend integration — backend receives events, stores them, and sends push via FCM/APNs.
- Step 6: Load testing — simulate 1000 transactions per minute, check stability.
- Step 7: Deployment and monitoring — deploy to production and track metrics.
What's included in a turnkey solution
- Multi-chain architecture (EVM + Solana optional)
- Wallet tracking and management of tracked addresses and contracts
- Event feed with filters and search
- Push notifications with amount/type filtering, quiet hours (transaction alerts)
- Detailed transaction card with block explorer link
- Offline mode with caching of recent events
- Integration with Alchemy Notify, QuickNode, or Moralis (by choice)
- Onchain monitoring for DeFi and dapp development
Timeline and cost
Timeline — 7–12 working days depending on the number of supported chains and integration depth. On average, projects cost $8,000–$15,000 and pay for themselves in 2-3 months through reduced manual monitoring overhead (saving $1,000–$3,000 per month) and fewer missed opportunities. Contact us for a preliminary estimate — we'll prepare the architecture and optimize the budget for your stack. Schedule a consultation to discuss details.