Real-Time Deposit Notifications for Your Self-Hosted AI Wallet

2026-04-07

Real-time deposit notifications transform your self-hosted AI wallet from a passive vault into an intelligent agent that responds immediately to incoming funds, enabling autonomous trading, payment processing, and DeFi strategies without constant manual monitoring. Whether you're running a trading bot or a payment service, knowing when funds arrive is critical for automated workflows.

Why Deposit Monitoring Matters

Traditional crypto wallets are reactive — you check balances manually or refresh dashboards to see new transactions. But AI agents need to be proactive. When someone pays your bot, when DeFi yields are deposited, or when cross-chain bridges complete, your agent should know immediately and take action.

Self-hosted solutions give you complete control over this monitoring. No API rate limits from third-party services, no custody risks, and no dependency on external infrastructure that could go offline when you need it most.

WAIaaS Incoming Transaction Monitor

WAIaaS provides built-in real-time deposit monitoring with instant notifications across multiple channels. The system tracks all incoming transactions and can trigger immediate responses through your AI agents.

Here's how the monitoring system works:

# Start WAIaaS with Docker — monitoring starts automatically
docker run -d \
  --name waiaas \
  -p 127.0.0.1:3100:3100 \
  -v waiaas-data:/data \
  -e WAIAAS_AUTO_PROVISION=true \
  ghcr.io/minhoyoo-iotrust/waiaas:latest

# Check incoming transaction summary via API
curl http://127.0.0.1:3100/v1/wallet/incoming/summary \
  -H "Authorization: Bearer wai_sess_<token>"

The monitoring service automatically detects deposits across all supported networks (18 networks across Ethereum, Solana, and other chains) and categorizes them by type — native tokens, ERC-20/SPL tokens, NFTs, and DeFi protocol interactions.

Setting Up Notification Channels

WAIaaS supports 3 signing channels that double as notification channels: push notifications, Telegram, and WalletConnect. Configure them during setup:

# Set up notification channels via CLI
waiaas notification setup

# Or configure push notifications manually
curl -X POST http://127.0.0.1:3100/v1/notifications/push \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: my-secret-password" \
  -d '{
    "endpoint": "https://fcm.googleapis.com/fcm/send/...",
    "keys": {
      "p256dh": "...",
      "auth": "..."
    }
  }'

Once configured, incoming deposits trigger real-time notifications with transaction details, amount, sender address, and confirmation status.

AI Agent Response to Deposits

Your AI agents can query incoming transactions through the MCP integration or SDK, enabling immediate automated responses:

import { WAIaaSClient } from '@waiaas/sdk';

const client = new WAIaaSClient({
  baseUrl: 'http://127.0.0.1:3100',
  sessionToken: process.env.WAIAAS_SESSION_TOKEN,
});

// Poll for new deposits
async function checkDeposits() {
  const incoming = await client.listIncomingTransactions();
  
  for (const tx of incoming.filter(tx => tx.status === 'CONFIRMED' && !tx.processed)) {
    console.log(`New deposit: ${tx.amount} ${tx.symbol} from ${tx.from}`);
    
    // Trigger automated response
    if (tx.symbol === 'USDC' && parseFloat(tx.amount) >= 100) {
      await client.executeAction('jupiter-swap', 'swap', {
        inputMint: 'EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v', // USDC
        outputMint: 'So11111111111111111111111111111111111111112',  // SOL
        amount: (parseFloat(tx.amount) * 1000000).toString() // Convert to smallest unit
      });
    }
  }
}

setInterval(checkDeposits, 10000); // Check every 10 seconds

The system tracks transaction confirmations automatically, so you can reliably trigger actions only after deposits are final.

MCP Integration for Claude

If you're using Claude Desktop with the MCP integration, your AI assistant can monitor deposits conversationally:

{
  "mcpServers": {
    "waiaas": {
      "command": "npx",
      "args": ["-y", "@waiaas/mcp"],
      "env": {
        "WAIAAS_BASE_URL": "http://127.0.0.1:3100",
        "WAIAAS_SESSION_TOKEN": "wai_sess_<token>",
        "WAIAAS_DATA_DIR": "~/.waiaas"
      }
    }
  }
}

After setup, you can ask Claude:

Claude has access to all 45 MCP tools, including incoming transaction monitoring, so it can build complex deposit-triggered workflows.

Docker Compose for Production Monitoring

For production environments, use Docker Compose with persistent volumes and health checks:

services:
  daemon:
    image: ghcr.io/minhoyoo-iotrust/waiaas:latest
    container_name: waiaas-daemon
    ports:
      - "127.0.0.1:3100:3100"
    volumes:
      - waiaas-data:/data
    environment:
      - WAIAAS_DATA_DIR=/data
      - WAIAAS_DAEMON_HOSTNAME=0.0.0.0
      - WAIAAS_DAEMON_LOG_LEVEL=info
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:3100/health"]
      interval: 30s
      timeout: 5s
      start_period: 10s
      retries: 3

volumes:
  waiaas-data:
    driver: local

The health check ensures monitoring stays online, and restart policies handle any connectivity issues with RPC endpoints.

Privacy and Self-Custody Benefits

Self-hosting your deposit monitoring infrastructure provides several advantages:

Complete Privacy: Transaction monitoring happens entirely on your infrastructure. No third-party services see your wallet addresses, transaction patterns, or balances.

No API Limits: Direct RPC connections to blockchain networks mean no rate limiting from hosted wallet services.

Sovereign Infrastructure: Your monitoring can't be shut down by external providers. As long as your server runs, monitoring continues.

Custom Logic: Implement any deposit-triggered logic without restrictions from hosted platforms.

Quick Start

Get real-time deposit notifications running in under 5 minutes:

  1. Start WAIaaS with auto-provision:

    docker run -d \
  --name waiaas \
  -p 127.0.0.1:3100:3100 \
  -v waiaas-data:/data \
  -e WAIAAS_AUTO_PROVISION=true \
  ghcr.io/minhoyoo-iotrust/waiaas:latest

  2. Get your master password:

    docker exec waiaas cat /data/recovery.key

  3. Create a wallet and session:

    curl -X POST http://127.0.0.1:3100/v1/wallets \
  -H "Content-Type: application/json" \
  -H "X-Master-Password: <your-password>" \
  -d '{"name": "deposit-monitor", "chain": "solana", "environment": "mainnet"}'

  4. Fund your wallet and watch the logs for incoming transaction detection.

  5. Query deposits via API:

    curl http://127.0.0.1:3100/v1/wallet/incoming/summary \
  -H "Authorization: Bearer wai_sess_<token>"

What's Next

Real-time deposit monitoring is just the foundation. Combine it with WAIaaS's policy engine to create sophisticated automated workflows — auto-compound DeFi yields, rebalance portfolios based on incoming funds, or trigger cross-chain transfers when deposits hit certain thresholds.

Ready to build your own self-hosted AI wallet infrastructure? Clone the repository at GitHub or learn more at waiaas.ai.