Skip to content

jeremylongshore/tons-of-skills-marketplace / plugins/crypto/whale-alert-monitor/skills/monitoring-whale-activity

monitoring-whale-activity

Verified

Track large cryptocurrency transactions and whale wallet movements in real-time. Use when tracking large holder movements, exchange flows, or wallet activity. Trigger with phrases like "track whales", "monitor large transfers", "check whale activity", "exchange inflows", or "watch wallet".

FileKindSize
ARD.mdmarkdown3.6 KB
PRD.mdmarkdown2.8 KB
SKILL.mdskill md3.8 KB
config/settings.yamlconfig1.4 KB
references/errors.mdmarkdown2.8 KB
references/examples.mdmarkdown4.6 KB
references/implementation.mdmarkdown2.5 KB
scripts/formatters.pyscript8.4 KB
scripts/price_service.pyscript9.6 KB
scripts/wallet_labels.pyscript11.6 KB
scripts/whale_api.pyscript11.8 KB
scripts/whale_monitor.pyscript12.0 KB

scripts/formatters.py

View on GitHub
#!/usr/bin/env python3
"""
Whale Alert Formatters

Format whale transaction data for various outputs.

Author: Jeremy Longshore <jeremy@intentsolutions.io>
Version: 1.0.0
License: MIT
"""

import json
from datetime import datetime
from typing import Dict, Any, List


def format_usd(value: float) -> str:
    """Format USD value with appropriate suffix."""
    if value >= 1e9:
        return f"${value / 1e9:.2f}B"
    elif value >= 1e6:
        return f"${value / 1e6:.2f}M"
    elif value >= 1e3:
        return f"${value / 1e3:.1f}K"
    else:
        return f"${value:,.0f}"


def format_amount(amount: float, symbol: str) -> str:
    """Format token amount."""
    if amount >= 1e6:
        return f"{amount / 1e6:.2f}M {symbol}"
    elif amount >= 1e3:
        return f"{amount / 1e3:.1f}K {symbol}"
    else:
        return f"{amount:,.2f} {symbol}"


def format_address(address: str, length: int = 12) -> str:
    """Truncate address for display."""
    if len(address) <= length:
        return address
    half = (length - 3) // 2
    return f"{address[:half]}...{address[-half:]}"


def format_time_ago(timestamp: int) -> str:
    """Format timestamp as relative time.

    Note: Uses UTC time for consistency across timezones.
    """
    now = datetime.utcnow().timestamp()
    diff = now - timestamp

    if diff < 60:
        return f"{int(diff)}s ago"
    elif diff < 3600:
        return f"{int(diff / 60)}m ago"
    elif diff < 86400:
        return f"{int(diff / 3600)}h ago"
    else:
        return f"{int(diff / 86400)}d ago"


def format_timestamp(timestamp: int) -> str:
    """Format timestamp as UTC datetime string."""
    return datetime.utcfromtimestamp(timestamp).strftime("%Y-%m-%d %H:%M:%S UTC")


def format_whale_table(transactions: List[Any], show_addresses: bool = False) -> str:
    """Format whale transactions as ASCII table.

    Args:
        transactions: List of WhaleTransaction objects
        show_addresses: Include full addresses in output

    Returns:
        Formatted table string
    """
    if not transactions:
        return "No whale transactions found."

    lines = [
        "",
        "WHALE ALERT - Recent Large Transactions",
        "=" * 100,
    ]

    if show_addresses:
        lines.append(f"{'Time':<12} {'Chain':<10} {'Amount':<20} {'USD Value':<14} {'From':<20} {'To':<20}")
    else:
        lines.append(
            f"{'Time':<12} {'Chain':<10} {'Amount':<20} {'USD Value':<14} {'From':<18} {'To':<18} {'Type':<10}"
        )

    lines.append("-" * 100)

    for tx in transactions:
        time_str = format_time_ago(tx.timestamp)
        chain = tx.blockchain[:8]
        amount_str = format_amount(tx.amount, tx.symbol)
        usd_str = format_usd(tx.amount_usd)

        # Label or address
        from_label = tx.from_owner if tx.from_owner else format_address(tx.from_address, 16)
        to_label = tx.to_owner if tx.to_owner else format_address(tx.to_address, 16)

        tx_type = tx.transaction_type[:8] if tx.transaction_type else "transfer"

        if show_addresses:
            lines.append(f"{time_str:<12} {chain:<10} {amount_str:<20} {usd_str:<14} {from_label:<20} {to_label:<20}")
        else:
            lines.append(
                f"{time_str:<12} {chain:<10} {amount_str:<20} {usd_str:<14} {from_label:<18} {to_label:<18} {tx_type:<10}"
            )

    lines.append("-" * 100)
    lines.append(f"Total: {len(transactions)} transactions")

    return "\n".join(lines)


def format_whale_alert(transaction: Any) -> str:
    """Format single transaction as alert message.

    Args:
        transaction: WhaleTransaction object

    Returns:
        Alert-style formatted string
    """
    time_str = format_timestamp(transaction.timestamp)
    amount_str = format_amount(transaction.amount, transaction.symbol)
    usd_str = format_usd(transaction.amount_usd)

    from_label = transaction.from_owner or format_address(transaction.from_address)
    to_label = transaction.to_owner or format_address(transaction.to_address)

    # Determine emoji based on transaction type
    if transaction.to_owner_type == "exchange":
        emoji = "πŸ”΄"  # Selling pressure
        direction = "DEPOSIT"
    elif transaction.from_owner_type == "exchange":
        emoji = "🟒"  # Buying/withdrawal
        direction = "WITHDRAWAL"
    else:
        emoji = "πŸ‹"
        direction = "TRANSFER"

    lines = [
        f"{emoji} WHALE {direction}",
        f"   {amount_str} ({usd_str})",
        f"   {from_label} β†’ {to_label}",
        f"   Chain: {transaction.blockchain.upper()} | {time_str}",
        f"   TX: {format_address(transaction.tx_hash, 20)}",
    ]

    return "\n".join(lines)


def format_exchange_flow(inflows: List[Dict[str, Any]], outflows: List[Dict[str, Any]]) -> str:
    """Format exchange inflow/outflow summary.

    Args:
        inflows: List of inflow transactions
        outflows: List of outflow transactions

    Returns:
        Formatted flow summary
    """
    total_inflow = sum(tx.get("amount_usd", 0) for tx in inflows)
    total_outflow = sum(tx.get("amount_usd", 0) for tx in outflows)
    net_flow = total_inflow - total_outflow

    lines = [
        "",
        "EXCHANGE FLOW ANALYSIS",
        "=" * 50,
        f"Inflows:  {format_usd(total_inflow):>14} ({len(inflows)} txns)",
        f"Outflows: {format_usd(total_outflow):>14} ({len(outflows)} txns)",
        "-" * 50,
    ]

    if net_flow > 0:
        lines.append(f"Net Flow: {format_usd(net_flow):>14} (SELLING PRESSURE)")
    elif net_flow < 0:
        lines.append(f"Net Flow: {format_usd(abs(net_flow)):>14} (BUYING PRESSURE)")
    else:
        lines.append(f"Net Flow: {format_usd(0):>14} (NEUTRAL)")

    lines.append("=" * 50)

    return "\n".join(lines)


def format_watchlist(wallets: List[Any]) -> str:
    """Format watchlist display.

    Args:
        wallets: List of WalletLabel objects

    Returns:
        Formatted watchlist
    """
    if not wallets:
        return "Watchlist is empty. Add wallets with: --watch <address> --name <name>"

    lines = [
        "",
        "WHALE WATCHLIST",
        "=" * 80,
        f"{'Name':<25} {'Address':<45} {'Chain':<10}",
        "-" * 80,
    ]

    for wallet in wallets:
        name = wallet.name[:23]
        address = format_address(wallet.address, 42)
        chain = wallet.chain[:8]
        lines.append(f"{name:<25} {address:<45} {chain:<10}")

    lines.append("-" * 80)
    lines.append(f"Total: {len(wallets)} watched wallets")

    return "\n".join(lines)


def format_transaction_detail(tx: Any, label_info: Dict = None) -> str:
    """Format detailed transaction view.

    Args:
        tx: WhaleTransaction object
        label_info: Additional label info

    Returns:
        Detailed formatted output
    """
    lines = [
        "",
        "TRANSACTION DETAIL",
        "=" * 70,
        f"TX Hash:    {tx.tx_hash}",
        f"Chain:      {tx.blockchain.upper()}",
        f"Time:       {format_timestamp(tx.timestamp)}",
        "",
        f"Amount:     {format_amount(tx.amount, tx.symbol)}",
        f"USD Value:  {format_usd(tx.amount_usd)}",
        f"Type:       {tx.transaction_type}",
        "",
        "FROM:",
        f"  Address:  {tx.from_address}",
        f"  Label:    {tx.from_owner or 'Unknown'}",
        f"  Type:     {tx.from_owner_type or 'Unknown'}",
        "",
        "TO:",
        f"  Address:  {tx.to_address}",
        f"  Label:    {tx.to_owner or 'Unknown'}",
        f"  Type:     {tx.to_owner_type or 'Unknown'}",
        "=" * 70,
    ]

    return "\n".join(lines)


def format_json(data: Any) -> str:
    """Format data as JSON."""
    if hasattr(data, "__iter__") and not isinstance(data, (str, dict)):
        # Handle list of dataclass objects
        serialized = []
        for item in data:
            if hasattr(item, "__dict__"):
                serialized.append(vars(item))
            else:
                serialized.append(item)
        return json.dumps(serialized, indent=2, default=str)
    elif hasattr(data, "__dict__"):
        return json.dumps(vars(data), indent=2, default=str)
    else:
        return json.dumps(data, indent=2, default=str)


def main():
    """CLI entry point for testing."""
    # Test formatting functions
    print("=== Format Tests ===")
    print(f"USD: {format_usd(1234567890)}")
    print(f"Amount: {format_amount(5000000, 'ETH')}")
    print(f"Address: {format_address('0x1234567890abcdef1234567890abcdef12345678')}")

    import time

    print(f"Time ago: {format_time_ago(int(time.time()) - 3600)}")


if __name__ == "__main__":
    main()
slack-gif-creatoranthropics/skillsKnowledge and utilities for creating animated GIFs optimized for Slack. Provides constraints, validation tools, and animation concepts. Use when users request animated GIFs for Slack like "make me a GIF of X doing Y for Slack."Stars: 198kUpdated Claude CodeCodexVerifiedInstall
ponytailDietrichGebert/ponytailLazy senior dev mode for any coding task: the smallest change that fully solves it, and a reply a busy human understands in one read.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailHarvest every shortcut: comment into one debt ledger, so deferrals get tracked instead of forgotten. One-shot report.Stars: 196kUpdated Claude CodeCodexVerifiedInstall
ponytail-debtDietrichGebert/ponytailList every `shortcut:` comment (and older `ponytail:` ones) as a debt ledger. One-shot report, changes nothing. Use for "ponytail debt", "what did ponytail defer", "list the shortcuts", /ponytail-debt.Stars: 196kUpdated Claude CodeCodexVerifiedInstall