home / skills / jeremylongshore / claude-code-plugins-plus-skills / monitoring-cross-chain-bridges

This skill monitors cross-chain bridge TVL, fees, and transaction status across networks to help compare routes and track bridge activity.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill monitoring-cross-chain-bridges

Review the files below or copy the command above to add this skill to your agents.

Files (13)
SKILL.md
3.9 KB
---
name: monitoring-cross-chain-bridges
description: |
  Monitor cross-chain bridge TVL, volume, fees, and transaction status across networks.
  Use when researching bridges, comparing routes, or tracking bridge transactions.
  Trigger with phrases like "monitor bridges", "compare bridge fees", "track bridge tx",
  "bridge TVL", or "cross-chain transfer status".

allowed-tools: Read, Write, Edit, Grep, Glob, Bash(python*bridge_monitor*)
version: 1.0.0
author: Jeremy Longshore <[email protected]>
license: MIT
---

# Cross-Chain Bridge Monitor

## Overview

Monitor cross-chain bridge activity across multiple protocols. Track TVL, compare fees and transfer times, and monitor transaction status for bridges like Stargate, Across, Wormhole, and LayerZero.

## Prerequisites

Before using this skill, ensure you have:
- Python 3.8+ with `requests` library
- Internet access for DefiLlama and bridge APIs
- Optional: Custom RPC URLs for on-chain verification

## Commands

### tvl - Bridge TVL Rankings
```bash
python bridge_monitor.py tvl --limit 20
```
Shows bridges ranked by Total Value Locked.

### bridges - List All Bridges
```bash
python bridge_monitor.py bridges
python bridge_monitor.py bridges --chain arbitrum
```
Lists bridges by 24h volume with optional chain filter.

### detail - Bridge Details
```bash
python bridge_monitor.py detail --bridge stargate
```
Shows detailed info including volume, chains, and TVL breakdown.

### compare - Compare Routes
```bash
python bridge_monitor.py compare --source ethereum --dest arbitrum --amount 1000 --token USDC
```
Compares fees and transfer times across bridges for a route.

### tx - Track Transaction
```bash
python bridge_monitor.py tx --tx-hash 0x...
python bridge_monitor.py tx --tx-hash 0x... --bridge wormhole
```
Tracks bridge transaction status across protocols.

### chains - List Chains
```bash
python bridge_monitor.py chains
```
Shows all supported chains.

### protocols - List Protocols
```bash
python bridge_monitor.py protocols
```
Shows supported bridge protocols with their chains.

## Instructions

1. **Check bridge TVL rankings**:
   ```bash
   cd {baseDir}/scripts
   python bridge_monitor.py tvl
   ```

2. **Compare bridge routes** before transferring:
   ```bash
   python bridge_monitor.py compare -s ethereum -d base -a 5000 -t USDC
   ```

3. **Get bridge details** for research:
   ```bash
   python bridge_monitor.py detail --bridge across
   ```

4. **Track a transaction**:
   ```bash
   python bridge_monitor.py tx --tx-hash 0x1234...
   ```

5. **Export to JSON** for analysis:
   ```bash
   python bridge_monitor.py -f json bridges > bridges.json
   ```

## Supported Bridges

| Bridge | Type | Avg Time | Typical Fee |
|--------|------|----------|-------------|
| Wormhole | Messaging | ~15 min | ~0.1% |
| LayerZero | Messaging | ~3 min | ~0.06% |
| Stargate | Liquidity | ~2 min | ~0.06% |
| Across | Liquidity | ~1 min | ~0.04% |

## Supported Chains

- Ethereum, BSC, Polygon, Arbitrum, Optimism
- Base, Avalanche, Fantom, Solana (Wormhole)
- 45+ total chains via DefiLlama

## Output

- **TVL rankings**: Bridges sorted by locked value
- **Fee comparison**: Side-by-side fee and time estimates
- **TX status**: Source/destination confirmation status
- **JSON format**: Structured data with `-f json` flag

## Error Handling

See `{baseDir}/references/errors.md` for comprehensive error handling including:
- API unavailability and fallback behavior
- Transaction tracking edge cases
- Rate limiting mitigation

## Examples

See `{baseDir}/references/examples.md` for detailed examples including:
- Finding best route for large transfers
- Monitoring transactions after bridging
- Research workflows for bridge safety

## Resources

- [DefiLlama Bridges](https://defillama.com/bridges) - Bridge TVL and volume
- [Wormhole Scan](https://wormholescan.io/) - Wormhole transaction explorer
- [LayerZero Scan](https://layerzeroscan.com/) - LayerZero message explorer
- [Across Protocol](https://across.to/) - Optimistic bridge

Overview

This skill monitors cross-chain bridge activity to help you research, compare, and track transfers across networks. It collects TVL, 24h volume, fees, average transfer times, and transaction status for major bridges like Stargate, Across, Wormhole, and LayerZero. Use it to rank bridges by TVL, compare route costs and latency, or follow a specific bridge transaction end-to-end.

How this skill works

The skill queries on-chain data and public bridge APIs (DefiLlama and protocol endpoints) to aggregate TVL, volume, fee estimates, and typical transfer times. It can compare routes by source/destination/token/amount and surface side-by-side fee and time estimates. For transaction tracking it polls bridge-specific explorers and verifies on-chain confirmations, with optional RPC checks for additional assurance.

When to use it

  • Research bridge safety and market share by TVL and volume
  • Compare fees and expected transfer times before moving funds
  • Track the status of an ongoing cross-chain transfer by tx hash
  • Audit bridge activity across multiple protocols and chains
  • Export structured JSON for analysis or reporting

Best practices

  • Always compare multiple bridges for a given route — cheapest is not always fastest or safest
  • Verify large transfers with on-chain RPC checks in addition to API responses
  • Use the JSON export for automated workflows or downstream analytics
  • Respect API rate limits and add retries/backoff when polling transaction status
  • Double-check destination chain compatibility and token wrappers before initiating transfers

Example use cases

  • Rank top 20 bridges by TVL to prioritize security research
  • Compare USDC transfer costs and times from Ethereum to Arbitrum for a $1,000 transfer
  • Retrieve detailed breakdown for a specific bridge including per-chain TVL and 24h volume
  • Track a Wormhole or LayerZero tx hash to confirm source and destination finality
  • Export bridges list to JSON for inclusion in a monitoring dashboard

FAQ

Which bridges and chains are supported?

Major bridges such as Wormhole, LayerZero, Stargate, Across and 45+ chains via DefiLlama are supported; availability depends on upstream APIs.

What do fee and time estimates represent?

Estimates combine protocol-reported typical fees and observed average transfer times; actual values can vary with network congestion and destination finality policies.

Can I verify transactions on-chain?

Yes. The skill can optionally use custom RPC endpoints to verify confirmations on source and destination chains when API data is ambiguous.

How do I get machine-readable output?

Use the JSON output flag to export structured results for automation, reporting, or integration with dashboards.