@intentsolutionsio/token-launch-tracker 1.0.0

package/skills/tracking-token-launches/scripts/dex_sources.py

@@ -0,0 +1,270 @@
+#!/usr/bin/env python3
+"""
+DEX Factory Addresses
+
+Factory contract addresses for detecting new pairs.
+
+Author: Jeremy Longshore <jeremy@intentsolutions.io>
+Version: 1.0.0
+License: MIT
+"""
+
+from dataclasses import dataclass
+from typing import Dict, List
+
+# PairCreated event signature for Uniswap V2 style
+PAIR_CREATED_TOPIC = "0x0d3648bd0f6ba80134a33ba9275ac585d9d315f0ad8355cddefde31afa28d0e9"
+
+
+@dataclass
+class DexFactory:
+    """DEX factory configuration."""
+    name: str
+    address: str
+    version: str  # v2 or v3
+    pair_created_topic: str
+
+
+@dataclass
+class ChainConfig:
+    """Chain configuration."""
+    name: str
+    chain_id: int
+    rpc_url: str
+    native_symbol: str
+    wrapped_native: str
+    block_time: float
+    explorer_url: str
+
+
+# Chain configurations
+CHAINS: Dict[str, ChainConfig] = {
+    "ethereum": ChainConfig(
+        name="Ethereum",
+        chain_id=1,
+        rpc_url="https://eth.llamarpc.com",
+        native_symbol="ETH",
+        wrapped_native="0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2",
+        block_time=12.0,
+        explorer_url="https://etherscan.io",
+    ),
+    "bsc": ChainConfig(
+        name="BNB Chain",
+        chain_id=56,
+        rpc_url="https://bsc-dataseed1.binance.org",
+        native_symbol="BNB",
+        wrapped_native="0xbb4CdB9CBd36B01bD1cBaEBF2De08d9173bc095c",
+        block_time=3.0,
+        explorer_url="https://bscscan.com",
+    ),
+    "arbitrum": ChainConfig(
+        name="Arbitrum One",
+        chain_id=42161,
+        rpc_url="https://arb1.arbitrum.io/rpc",
+        native_symbol="ETH",
+        wrapped_native="0x82aF49447D8a07e3bd95BD0d56f35241523fBab1",
+        block_time=0.25,
+        explorer_url="https://arbiscan.io",
+    ),
+    "base": ChainConfig(
+        name="Base",
+        chain_id=8453,
+        rpc_url="https://mainnet.base.org",
+        native_symbol="ETH",
+        wrapped_native="0x4200000000000000000000000000000000000006",
+        block_time=2.0,
+        explorer_url="https://basescan.org",
+    ),
+    "polygon": ChainConfig(
+        name="Polygon",
+        chain_id=137,
+        rpc_url="https://polygon-rpc.com",
+        native_symbol="MATIC",
+        wrapped_native="0x0d500B1d8E8eF31E21C99d1Db9A6444d3ADf1270",
+        block_time=2.0,
+        explorer_url="https://polygonscan.com",
+    ),
+}
+
+
+# DEX factory addresses per chain
+DEX_FACTORIES: Dict[str, Dict[str, DexFactory]] = {
+    "ethereum": {
+        "uniswap_v2": DexFactory(
+            name="Uniswap V2",
+            address="0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f",
+            version="v2",
+            pair_created_topic=PAIR_CREATED_TOPIC,
+        ),
+        "uniswap_v3": DexFactory(
+            name="Uniswap V3",
+            address="0x1F98431c8aD98523631AE4a59f267346ea31F984",
+            version="v3",
+            pair_created_topic="0x783cca1c0412dd0d695e784568c96da2e9c22ff989357a2e8b1d9b2b4e6b7118",
+        ),
+        "sushiswap": DexFactory(
+            name="SushiSwap",
+            address="0xC0AEe478e3658e2610c5F7A4A2E1777cE9e4f2Ac",
+            version="v2",
+            pair_created_topic=PAIR_CREATED_TOPIC,
+        ),
+    },
+    "bsc": {
+        "pancakeswap_v2": DexFactory(
+            name="PancakeSwap V2",
+            address="0xcA143Ce32Fe78f1f7019d7d551a6402fC5350c73",
+            version="v2",
+            pair_created_topic=PAIR_CREATED_TOPIC,
+        ),
+        "pancakeswap_v3": DexFactory(
+            name="PancakeSwap V3",
+            address="0x0BFbCF9fa4f9C56B0F40a671Ad40E0805A091865",
+            version="v3",
+            pair_created_topic="0x783cca1c0412dd0d695e784568c96da2e9c22ff989357a2e8b1d9b2b4e6b7118",
+        ),
+    },
+    "arbitrum": {
+        "uniswap_v3": DexFactory(
+            name="Uniswap V3",
+            address="0x1F98431c8aD98523631AE4a59f267346ea31F984",
+            version="v3",
+            pair_created_topic="0x783cca1c0412dd0d695e784568c96da2e9c22ff989357a2e8b1d9b2b4e6b7118",
+        ),
+        "camelot": DexFactory(
+            name="Camelot",
+            address="0x6EcCab422D763aC031210895C81787E87B43A652",
+            version="v2",
+            pair_created_topic=PAIR_CREATED_TOPIC,
+        ),
+        "sushiswap": DexFactory(
+            name="SushiSwap",
+            address="0xc35DADB65012eC5796536bD9864eD8773aBc74C4",
+            version="v2",
+            pair_created_topic=PAIR_CREATED_TOPIC,
+        ),
+    },
+    "base": {
+        "uniswap_v3": DexFactory(
+            name="Uniswap V3",
+            address="0x33128a8fC17869897dcE68Ed026d694621f6FDfD",
+            version="v3",
+            pair_created_topic="0x783cca1c0412dd0d695e784568c96da2e9c22ff989357a2e8b1d9b2b4e6b7118",
+        ),
+        "aerodrome": DexFactory(
+            name="Aerodrome",
+            address="0x420DD381b31aEf6683db6B902084cB0FFECe40Da",
+            version="v2",
+            pair_created_topic=PAIR_CREATED_TOPIC,
+        ),
+    },
+    "polygon": {
+        "uniswap_v3": DexFactory(
+            name="Uniswap V3",
+            address="0x1F98431c8aD98523631AE4a59f267346ea31F984",
+            version="v3",
+            pair_created_topic="0x783cca1c0412dd0d695e784568c96da2e9c22ff989357a2e8b1d9b2b4e6b7118",
+        ),
+        "quickswap": DexFactory(
+            name="QuickSwap",
+            address="0x5757371414417b8C6CAad45bAeF941aBc7d3Ab32",
+            version="v2",
+            pair_created_topic=PAIR_CREATED_TOPIC,
+        ),
+        "sushiswap": DexFactory(
+            name="SushiSwap",
+            address="0xc35DADB65012eC5796536bD9864eD8773aBc74C4",
+            version="v2",
+            pair_created_topic=PAIR_CREATED_TOPIC,
+        ),
+    },
+}
+
+
+# Common stablecoins per chain (for base pair detection)
+STABLECOINS: Dict[str, List[str]] = {
+    "ethereum": [
+        "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",  # USDC
+        "0xdAC17F958D2ee523a2206206994597C13D831ec7",  # USDT
+        "0x6B175474E89094C44Da98b954E2deC563975aA61",  # DAI
+    ],
+    "bsc": [
+        "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",  # USDC
+        "0x55d398326f99059fF775485246999027B3197955",  # USDT
+        "0xe9e7CEA3DedcA5984780Bafc599bD69ADd087D56",  # BUSD
+    ],
+    "arbitrum": [
+        "0xFF970A61A04b1cA14834A43f5dE4533eBDDB5CC8",  # USDC.e
+        "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",  # USDC
+        "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",  # USDT
+    ],
+    "base": [
+        "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",  # USDC
+        "0xd9aAEc86B65D86f6A7B5B1b0c42FFA531710b6CA",  # USDbC
+    ],
+    "polygon": [
+        "0x2791Bca1f2de4661ED88A30C99A7a9449Aa84174",  # USDC
+        "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",  # USDT
+        "0x8f3Cf7ad23Cd3CaDbD9735AFf958023239c6A063",  # DAI
+    ],
+}
+
+
+def get_chain_config(chain: str) -> ChainConfig:
+    """Get chain configuration."""
+    chain = chain.lower()
+    if chain not in CHAINS:
+        raise ValueError(f"Unsupported chain: {chain}. Supported: {list(CHAINS.keys())}")
+    return CHAINS[chain]
+
+
+def get_dex_factories(chain: str) -> Dict[str, DexFactory]:
+    """Get DEX factories for a chain."""
+    chain = chain.lower()
+    return DEX_FACTORIES.get(chain, {})
+
+
+def get_all_factory_addresses(chain: str) -> List[str]:
+    """Get all factory addresses for a chain."""
+    factories = get_dex_factories(chain)
+    return [f.address.lower() for f in factories.values()]
+
+
+def identify_dex(chain: str, factory_address: str) -> str:
+    """Identify DEX by factory address."""
+    factories = get_dex_factories(chain)
+    factory_address = factory_address.lower()
+
+    for name, factory in factories.items():
+        if factory.address.lower() == factory_address:
+            return factory.name
+
+    return "Unknown DEX"
+
+
+def is_base_token(chain: str, address: str) -> bool:
+    """Check if address is a base token (stablecoin or wrapped native)."""
+    address = address.lower()
+    chain_config = get_chain_config(chain)
+
+    if address == chain_config.wrapped_native.lower():
+        return True
+
+    stables = STABLECOINS.get(chain, [])
+    return address in [s.lower() for s in stables]
+
+
+def main():
+    """CLI entry point for testing."""
+    print("=== Supported Chains ===")
+    for chain_id, config in CHAINS.items():
+        print(f"  {chain_id}: {config.name} (Chain ID: {config.chain_id})")
+
+    print("\n=== DEX Factories ===")
+    for chain_id, factories in DEX_FACTORIES.items():
+        print(f"\n{chain_id.upper()}:")
+        for name, factory in factories.items():
+            print(f"  {factory.name} ({factory.version}): {factory.address[:20]}...")
+
+
+if __name__ == "__main__":
+    main()

package/skills/tracking-token-launches/scripts/event_monitor.py

@@ -0,0 +1,345 @@
+#!/usr/bin/env python3
+"""
+Blockchain Event Monitor
+
+Monitor DEX factory events for new pair creations.
+
+Author: Jeremy Longshore <jeremy@intentsolutions.io>
+Version: 1.0.0
+License: MIT
+"""
+
+import os
+import time
+from dataclasses import dataclass
+from typing import Dict, Any, List, Optional
+
+try:
+    import requests
+except ImportError:
+    requests = None
+
+from dex_sources import (
+    get_chain_config,
+    get_dex_factories,
+    identify_dex,
+    is_base_token,
+    PAIR_CREATED_TOPIC,
+)
+
+
+@dataclass
+class PairCreated:
+    """New trading pair event."""
+    block_number: int
+    tx_hash: str
+    timestamp: int
+    pair_address: str
+    token0: str
+    token1: str
+    dex: str
+    chain: str
+    factory_address: str
+
+
+@dataclass
+class TokenBasicInfo:
+    """Basic token info from RPC."""
+    address: str
+    name: str
+    symbol: str
+    decimals: int
+
+
+class EventMonitor:
+    """Monitor blockchain events for new pairs."""
+
+    def __init__(
+        self,
+        chain: str = "ethereum",
+        rpc_url: str = None,
+        verbose: bool = False
+    ):
+        """Initialize event monitor.
+
+        Args:
+            chain: Chain to monitor
+            rpc_url: Custom RPC URL
+            verbose: Enable verbose output
+        """
+        self.chain = chain.lower()
+        self.config = get_chain_config(chain)
+        self.rpc_url = rpc_url or os.environ.get(
+            f"{chain.upper()}_RPC_URL",
+            self.config.rpc_url
+        )
+        self.verbose = verbose
+        # Use a size-limited cache to prevent memory leaks on long-running instances
+        # Keeps most recent 1000 block timestamps
+        self._block_cache = {}
+        self._block_cache_max_size = 1000
+
+    def _rpc_call(self, method: str, params: List = None) -> Any:
+        """Make JSON-RPC call."""
+        if not requests:
+            raise ImportError("requests library required")
+
+        if self.verbose:
+            print(f"RPC: {method}")
+
+        response = requests.post(
+            self.rpc_url,
+            json={
+                "jsonrpc": "2.0",
+                "method": method,
+                "params": params or [],
+                "id": 1,
+            },
+            headers={"Content-Type": "application/json"},
+            timeout=30,
+        )
+        response.raise_for_status()
+
+        result = response.json()
+        if "error" in result:
+            raise Exception(f"RPC error: {result['error']}")
+
+        return result.get("result")
+
+    def _get_block_timestamp(self, block_number: int) -> int:
+        """Get block timestamp with size-limited caching."""
+        if block_number in self._block_cache:
+            return self._block_cache[block_number]
+
+        block = self._rpc_call(
+            "eth_getBlockByNumber",
+            [hex(block_number), False]
+        )
+
+        if block:
+            timestamp = int(block.get("timestamp", "0x0"), 16)
+
+            # Evict old entries if cache is full
+            if len(self._block_cache) >= self._block_cache_max_size:
+                # Remove oldest entries (first 100)
+                oldest_keys = sorted(self._block_cache.keys())[:100]
+                for key in oldest_keys:
+                    del self._block_cache[key]
+
+            self._block_cache[block_number] = timestamp
+            return timestamp
+
+        return int(time.time())
+
+    def get_current_block(self) -> int:
+        """Get current block number."""
+        result = self._rpc_call("eth_blockNumber")
+        return int(result, 16)
+
+    def get_recent_pairs(
+        self,
+        hours: int = 24,
+        dex: str = None
+    ) -> List[PairCreated]:
+        """Get recently created pairs.
+
+        Args:
+            hours: Hours to look back
+            dex: Filter by specific DEX
+
+        Returns:
+            List of PairCreated events
+        """
+        current_block = self.get_current_block()
+        blocks_per_hour = int(3600 / self.config.block_time)
+        from_block = current_block - (blocks_per_hour * hours)
+
+        factories = get_dex_factories(self.chain)
+        factory_addresses = []
+
+        for name, factory in factories.items():
+            if dex is None or dex.lower() in name.lower():
+                factory_addresses.append(factory.address)
+
+        if not factory_addresses:
+            return []
+
+        pairs = []
+
+        for factory_addr in factory_addresses:
+            try:
+                logs = self._rpc_call("eth_getLogs", [{
+                    "fromBlock": hex(from_block),
+                    "toBlock": "latest",
+                    "address": factory_addr,
+                    "topics": [PAIR_CREATED_TOPIC],
+                }])
+
+                for log in logs or []:
+                    pair = self._parse_pair_created(log, factory_addr)
+                    if pair:
+                        pairs.append(pair)
+
+            except Exception as e:
+                if self.verbose:
+                    print(f"Error fetching logs from {factory_addr}: {e}")
+
+        # Sort by block number descending (newest first)
+        pairs.sort(key=lambda x: x.block_number, reverse=True)
+
+        return pairs
+
+    def _parse_pair_created(
+        self,
+        log: Dict,
+        factory_address: str
+    ) -> Optional[PairCreated]:
+        """Parse PairCreated event log."""
+        try:
+            block_number = int(log["blockNumber"], 16)
+            tx_hash = log["transactionHash"]
+            topics = log.get("topics", [])
+            data = log.get("data", "0x")
+
+            # For Uniswap V2 style: topics[1] = token0, topics[2] = token1
+            # data contains pair address and pair index
+            if len(topics) >= 3:
+                token0 = "0x" + topics[1][-40:]
+                token1 = "0x" + topics[2][-40:]
+
+                # Pair address is first 32 bytes of data
+                pair_address = "0x" + data[26:66]
+
+                timestamp = self._get_block_timestamp(block_number)
+                dex = identify_dex(self.chain, factory_address)
+
+                return PairCreated(
+                    block_number=block_number,
+                    tx_hash=tx_hash,
+                    timestamp=timestamp,
+                    pair_address=pair_address,
+                    token0=token0,
+                    token1=token1,
+                    dex=dex,
+                    chain=self.chain,
+                    factory_address=factory_address,
+                )
+
+        except Exception as e:
+            if self.verbose:
+                print(f"Error parsing log: {e}")
+
+        return None
+
+    def get_token_info(self, address: str) -> Optional[TokenBasicInfo]:
+        """Get basic token info via RPC calls.
+
+        Args:
+            address: Token contract address
+
+        Returns:
+            TokenBasicInfo or None
+        """
+        try:
+            # ERC20 function signatures
+            name_sig = "0x06fdde03"  # name()
+            symbol_sig = "0x95d89b41"  # symbol()
+            decimals_sig = "0x313ce567"  # decimals()
+
+            name = self._call_contract(address, name_sig)
+            symbol = self._call_contract(address, symbol_sig)
+            decimals = self._call_contract(address, decimals_sig)
+
+            return TokenBasicInfo(
+                address=address,
+                name=self._decode_string(name) if name else "Unknown",
+                symbol=self._decode_string(symbol) if symbol else "???",
+                decimals=int(decimals, 16) if decimals else 18,
+            )
+
+        except Exception as e:
+            if self.verbose:
+                print(f"Error getting token info for {address}: {e}")
+            return None
+
+    def _call_contract(self, address: str, data: str) -> Optional[str]:
+        """Make eth_call to contract."""
+        try:
+            result = self._rpc_call("eth_call", [
+                {"to": address, "data": data},
+                "latest"
+            ])
+            return result if result and result != "0x" else None
+        except Exception:
+            return None
+
+    def _decode_string(self, data: str) -> str:
+        """Decode string from ABI-encoded data."""
+        if not data or data == "0x":
+            return ""
+
+        try:
+            # Remove 0x prefix
+            data = data[2:]
+
+            # If short string (< 32 bytes, not ABI encoded)
+            if len(data) <= 64:
+                return bytes.fromhex(data).decode("utf-8", errors="ignore").strip("\x00")
+
+            # ABI encoded string: offset (32 bytes) + length (32 bytes) + data
+            if len(data) >= 128:
+                length = int(data[64:128], 16)
+                string_data = data[128:128 + length * 2]
+                return bytes.fromhex(string_data).decode("utf-8", errors="ignore")
+
+            return bytes.fromhex(data).decode("utf-8", errors="ignore").strip("\x00")
+
+        except Exception:
+            return "Unknown"
+
+    def identify_new_token(self, pair: PairCreated) -> str:
+        """Identify which token in the pair is the new one.
+
+        Args:
+            pair: PairCreated event
+
+        Returns:
+            Address of the new token
+        """
+        # If one is a base token (WETH, stablecoin), the other is new
+        if is_base_token(self.chain, pair.token0):
+            return pair.token1
+        if is_base_token(self.chain, pair.token1):
+            return pair.token0
+
+        # Otherwise, consider both as potentially new
+        return pair.token0
+
+
+def main():
+    """CLI entry point for testing."""
+    monitor = EventMonitor(chain="ethereum", verbose=True)
+
+    print("=== Recent Pairs (Last 1 Hour) ===")
+    pairs = monitor.get_recent_pairs(hours=1)
+
+    if not pairs:
+        print("No new pairs found")
+        return
+
+    for pair in pairs[:10]:
+        print(f"\n{pair.dex} on {pair.chain}")
+        print(f"  Block: {pair.block_number}")
+        print(f"  Pair: {pair.pair_address[:20]}...")
+        print(f"  Token0: {pair.token0[:20]}...")
+        print(f"  Token1: {pair.token1[:20]}...")
+
+        # Get token info
+        new_token = monitor.identify_new_token(pair)
+        token_info = monitor.get_token_info(new_token)
+        if token_info:
+            print(f"  New Token: {token_info.symbol} ({token_info.name})")
+
+
+if __name__ == "__main__":
+    main()