dexther_lib 0.0.261

use ethers::types::{TransactionReceipt, H256, U256, U64};
use serde::Deserialize;
use serde::Serialize;
use std::collections::HashMap;

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct TokenInfo {
    pub address: String,
    pub name: String,
    pub symbol: String,
    pub decimals: String,
    pub owner: String,
    pub total_supply: String,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PairInfo {
    pub address: String,
    pub name: String,
    pub symbol: String,
    pub v3: Option<bool>,
    pub factory: String,
    pub tickSpacing: Option<i32>,
    pub fee: Option<i32>    
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PairInfoPub {
    pub token0: TokenInfo,
    pub token1: TokenInfo,
    pub pair: PairInfo,
    pub block_number: String,
    pub transaction_hash: String,
    pub log_index: String,
    pub _id: String,
    pub deployer: String,
    pub factory: String,
    pub v3: Option<bool>,
    pub tickSpacing: Option<i32>,
    pub fee: Option<i32>    
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
pub struct PairCreated {
    pub token0: String,
    pub token1: String,
    pub pair: String,
    pub block_number: String,
    pub transaction_hash: String,
    pub transaction_index: String,
    pub timestamp: String,
    pub deployer: String,
    pub factory: String,
    pub v3: Option<bool>,
    pub tickSpacing: Option<i32>,
    pub fee: Option<i32>    
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MintTransaction {
    pub _id: String,
    pub event_type: String,
    pub sender: String,
    pub amount_0: String,
    pub amount_1: String,
    pub pair: String,
    pub block_number: String,
    pub block_hash: String,
    pub tx_hash: String,
    pub log_index: String,
    pub tx_from: String,
    pub tx_to: Option<String>,
    pub v3: Option<bool>,
    pub tick_lower: Option<String>,
    pub tick_upper: Option<String>,}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BurnTransaction {
    pub _id: String,
    pub event_type: String,
    pub sender: String,
    pub to: String,
    pub amount_0: String,
    pub amount_1: String,
    pub pair: String,
    pub block_number: String,
    pub block_hash: String,
    pub tx_hash: String,
    pub log_index: String,
    pub tx_from: String,
    pub tx_to: Option<String>,
    pub v3: Option<bool>,
    pub tick_lower: Option<String>,
    pub tick_upper: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SwapTransaction {
    pub _id: String,
    pub event_type: String,
    pub sender: String,
    pub to: String,
    pub amount_0_in: String,
    pub amount_1_in: String,
    pub amount_0_out: String,
    pub amount_1_out: String,
    pub block_hash: String,
    pub pair: String,
    pub block_number: String,
    pub tx_hash: String,
    pub timestamp: String,
    pub log_index: String,
    pub tx_from: String,
    pub tx_to: Option<String>,
    pub v3: Option<bool>,
    pub sqrt_price_x96: Option<String>,
    pub liquidity_v3: Option<String>,
    pub tick: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Block {
    pub _id: String,
    pub block_hash: String,
    pub number: String,
    pub timestamp: String,
    pub gas_used: String,
    pub gas_limit: String,
    pub size: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TokenTransfer {
    pub _id: String,
    pub event_type: String,
    pub from: String,
    pub to: String,
    pub value: String,
    pub address: String,
    pub block_number: String,
    pub block_hash: String,
    pub tx_hash: String,
    pub log_index: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TokenState {
    pub total_supply: String,
    pub circ_supply: String,
    pub decimals: i64,
    pub address: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TokenStatePub {
    pub total_supply: String,
    pub circ_supply: String,
    pub token_address: String,
    pub block_number: i64,
    pub chain_id: u8,
}

impl TokenState {
    pub fn to_pub(&mut self, chain_id: u8, block_number: i64, address: String) -> TokenStatePub {
        TokenStatePub {
            total_supply: self.total_supply.clone(),
            circ_supply: self.circ_supply.clone(),
            token_address: address,
            block_number: block_number,
            chain_id: chain_id,
        }
    }
}

impl Default for TokenState {
    fn default() -> Self {
        return TokenState {
            address: "".to_string(),
            decimals: 0,
            total_supply: "0".to_string(),
            circ_supply: "0".to_string(),
        };
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct EnrichedTransaction {
    pub tx_hash: String,
    pub log_index: String,
    pub block_number: String,
    pub chain_id: String,
    pub pair_address: String,
    pub amount0_in: String,
    pub amount1_in: String,
    pub amount0_out: String,
    pub amount1_out: String,
    pub event_type: String,
    pub token0_price_usd: String,
    pub token1_price_usd: String,
    pub transaction_price: String,
    pub token0_amount: String,
    pub token1_amount: String,
    pub transaction_type: Option<String>,
    pub from: String,
    pub to: Option<String>,
    pub maker: String,
    pub tx_from: String,
    pub tx_to: Option<String>,
    pub block_timestamp: String,
    pub v3: Option<bool>,
    pub sqrt_price_x96: Option<String>,
    pub liquidity_v3: Option<String>,
    pub tick: Option<String>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct PairStatePub {
    pub pair_address: String,
    pub chain_id: u8,
    pub block_number: u64,
    pub block_timestamp: String,
    pub total_volume: f64,
    pub total_liquidity: f64,
    pub pooled_token0: String,
    pub pooled_token1: String,
    pub token0_decimals: u8,
    pub token1_decimals: u8,
    pub token0_symbol: String,
    pub token1_symbol: String,
    pub token0_address: String,
    pub token1_address: String,
    pub token0_price_in_token1: f64,
    pub token1_price_in_token0: f64,
    pub total_buys: u64,
    pub total_sells: u64,
    pub total_txns: u64,
    pub token0_price_usd: f64,
    pub token1_price_usd: f64,
}

#[derive(Debug, Serialize, Deserialize)]
pub struct BlockPub {
    pub number: U64,
    pub difficulty: Option<U256>,
    pub hash: H256,
    pub timestamp: U256,
    pub size: Option<U256>,
    pub gas_used: Option<U256>,
    pub gas_limit: Option<U256>,
    pub receipts: Vec<TransactionReceipt>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Lock {
    pub pair_address: String,
    pub user: Option<String>,
    pub amount: String,
    pub lock_date: Option<String>,
    pub unlock_date: String,
    pub lock_address: String,
    pub log_index: String,
    pub block_number: String,
    pub chain_id: String,
    pub tx_hash: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct OwnershipTransferred {
    pub tx_hash: String,
    pub log_index: String,
    pub block_number: String,
    pub maker: String,
    pub previous_owner: String,
    pub new_owner: String,
    pub token_address: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WindowMetricsPub {
    pub block_number: u8,
    pub pair_address: String,
    pub chain_id: i32,
    pub metrics: (
        Option<WindowMetrics>,
        Option<WindowMetrics>,
        Option<WindowMetrics>,
        Option<WindowMetrics>,
    ),
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct WindowMetrics {
    // Token 0 price
    pub token0_price: f64,
    // Token 1 price
    pub token1_price: f64,
    // Number of transactions
    pub tx_count: i32,
    // Total volume in usd
    pub volume_usd: f64,
    // Number of buys
    pub tx_buys: i32,
    // Number of sells
    pub tx_sells: i32,
    // Number of unique wallets
    pub unique_wallets: i32,
    // Number of unique wallets that made buys
    pub unique_wallets_buys: i32,
    // Number of unique wallets that made sells
    pub unique_wallets_sells: i32,
    // Number of transactions superior to 100 usd
    pub tx_sup_100_usd: i32,
    // Number of wallets with more than 20 transactions
    pub wallet_sup_20_tx: i32,
}

impl Default for WindowMetrics {
    fn default() -> Self {
        Self {
            token0_price: 0.0f64,
            token1_price: 0.0f64,
            tx_count: 0,
            volume_usd: 0.0f64,
            tx_buys: 0,
            tx_sells: 0,
            unique_wallets: 0,
            unique_wallets_buys: 0,
            unique_wallets_sells: 0,
            tx_sup_100_usd: 0,
            wallet_sup_20_tx: 0,
        }
    }
}

impl WindowMetrics {
    pub fn has_changed(&self, other: &WindowMetrics) -> bool {
        self.tx_count != other.tx_count
            || (self.volume_usd - other.volume_usd).abs() > f64::EPSILON
            || self.tx_buys != other.tx_buys
            || self.tx_sells != other.tx_sells
            || self.unique_wallets != other.unique_wallets
            || self.unique_wallets_buys != other.unique_wallets_buys
            || self.unique_wallets_sells != other.unique_wallets_sells
            || self.tx_sup_100_usd != other.tx_sup_100_usd
            || self.wallet_sup_20_tx != other.wallet_sup_20_tx
    }
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum Transaction {
    Block(Block),
    Swap(SwapTransaction),
    Mint(MintTransaction),
    Burn(BurnTransaction),
    TokenTransfer(TokenTransfer),
    PairInfoPub(PairInfoPub),
    Lock(Lock),
    OwnershipTransferred(OwnershipTransferred),
}

// In token_balances.rs
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HolderBalanceChange {
    pub token_address: String,
    pub chain_id: String,
    pub holder: String,
    pub new_balance: String,  // IBig as string, or use IBig directly
    pub block_number: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HolderCountChange {
    pub token_address: String,
    pub chain_id: String,
    pub new_holder_count: i32,
    pub block_number: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TokenSupplyChange {
    pub token_address: String,
    pub chain_id: String,
    pub total_minted: String,      // Cumulative minted amount (only increases)
    pub total_burned: String,       // Cumulative burned amount (only increases)
    pub circulating_supply: String, // Calculated: total_minted - total_burned
    pub block_number: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TokenBalanceChanges {
    pub holder_balances: Vec<HolderBalanceChange>,
    pub holder_count_changes: Vec<HolderCountChange>,
    pub supply_changes: Vec<TokenSupplyChange>,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
pub enum HolderPnlStatus {
    Flat,
    Profit,
    Loss,
    Exited,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum HolderPnlScope {
    Chain,
    Global,
}

#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub enum HolderPnlWindow {
    Block,
    Day,
    Week,
    Month,
    Custom,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HolderPnlChange {
    pub chain_id: String,
    pub token_address: Option<String>,
    pub pair_address: Option<String>,
    pub holder: String,
    pub position_size: String,
    pub average_entry_price: String,
    pub realized_pnl_usd: String,
    pub unrealized_pnl_usd: String,
    pub total_pnl_usd: String,
    pub status: HolderPnlStatus,
    pub scope: HolderPnlScope,
    pub window: HolderPnlWindow,
    pub block_number: u64,
    pub window_start_block: Option<u64>,
    pub window_end_block: Option<u64>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HolderPnlStatusBucket {
    pub status: HolderPnlStatus,
    pub holder_count: i64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HolderPnlStatusCount {
    pub chain_id: String,
    pub token_address: Option<String>,
    pub pair_address: Option<String>,
    pub scope: HolderPnlScope,
    pub window: HolderPnlWindow,
    pub block_number: u64,
    pub buckets: Vec<HolderPnlStatusBucket>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HolderPnlLeaderboardEntry {
    pub chain_id: String,
    pub token_address: Option<String>,
    pub pair_address: Option<String>,
    pub holder: String,
    pub position_size: String,
    pub average_entry_price: String,
    pub realized_pnl_usd: String,
    pub unrealized_pnl_usd: String,
    pub total_pnl_usd: String,
    pub rank: u32,
    pub scope: HolderPnlScope,
    pub window: HolderPnlWindow,
    pub block_number: u64,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct HolderPnlChanges {
    pub holder_changes: Vec<HolderPnlChange>,
    pub status_counts: Vec<HolderPnlStatusCount>,
    pub leaderboard_entries: Vec<HolderPnlLeaderboardEntry>,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub enum TransactionPub {
    Transaction(Transaction),
    EnrichedTransaction(EnrichedTransaction),
    PairStatePub(PairStatePub),
    TokenStatePub(TokenStatePub),
    PairInfoPub(PairInfoPub),
    WindowMetricsPub(WindowMetricsPub),
    TokenBalanceChangePub(TokenBalanceChanges),
    HolderPnlChangePub(HolderPnlChanges),
}

pub type TokensCollection = HashMap<String, TokenState>;