Fee Intelligence

// providers/bankr.ts
// Primary discovery — Bankr API
const launches = await bankr.fetchRecentLaunches(100);

for (const launch of launches) {
  if (launch.status !== 'deployed' || launch.chain !== 'base') continue;

  // Each launch has three distinct identities:
  const deployer         = launch.deployer.walletAddress;       // who signed the tx
  const feeRecipient     = launch.feeRecipient.walletAddress;   // where fees flow
  const projectTwitter   = launch.feeRecipient.xUsername        // company/project Twitter
                        ?? launch.deployer.xUsername;
  const poolId           = launch.poolId;  // 32-byte Uniswap V4 pool ID
}

// providers/bankr.ts
// GET /token-launches/:tokenAddress/fees?days=30
// Response shape:
{
  address: string,   // feeRecipient wallet
  tokens: [{
    tokenAddress: string,
    token0Label:  string,   // e.g. "WETH" or "BOND"
    token1Label:  string,   // e.g. "BOND" or "WETH" — ordering varies
    claimable: { token0: string, token1: string },  // amounts as strings
    claimed:   { token0: string, token1: string, count: number },
  }],
  totals: {
    claimableWeth: number,  // always WETH-denominated (reliable fallback)
    claimedWeth:   number,
    claimCount:    number,
  }
}

// Label-aware extraction — never assume token0 = WETH
extractUnclaimedEth(fees: BankrFeeData, tokenAddress: string): number {
  const entry = fees.tokens.find(t => t.tokenAddress?.toLowerCase() === addr);
  if (entry) {
    if (entry.token0Label === 'WETH') return parseFloat(entry.claimable.token0);
    if (entry.token1Label === 'WETH') return parseFloat(entry.claimable.token1);
  }
  // totals.claimableWeth is always correct regardless of pool ordering
  return parseFloat(String(fees.totals?.claimableWeth ?? 0));
}

const ethPriceUsd  = await dex.getEthPrice();        // fetched once per scan cycle
const unclaimedUsd = unclaimedEth * ethPriceUsd;   // ✓ correct
// const wrong = unclaimedEth * tokenPriceUsd;      // ✗ wrong — token price ≠ WETH price

// providers/baseChain.ts
async function getCreatorReward(lpAddress: string): Promise<number> {
  try {
    // V2 / V3: creatorReward(address) → uint256
    return await client.readContract({
      address: lpAddress,
      abi: CLANKER_V2_ABI,
      functionName: "creatorReward",
    });
  } catch {
    // V1 fallback: unclaimedFees() → uint256
    return await client.readContract({
      address: lpAddress,
      abi: CLANKER_V1_ABI,
      functionName: "unclaimedFees",
    });
  }
}

// Queue flow after fee scan:
// [fee scanner] → seshat-fee-queue → [composite scorer]
//                                           ↓
//                               if composite ≥ 65 AND research exists:
//                                    → seshat-alert-queue → Telegram / Discord
//
// Research is triggered separately every 6h for top tokens by volume.
// Threshold for research queue: market_cap_usd > $1,000

const ALERT_THRESHOLD    = 65;   // composite score — Telegram/Discord alert fires
const MIN_FEES_USD       = 10;   // minimum unclaimed USD to record a fee_claims row

// Checks per token (once per 24h):
// 1. Basescan source verification  → is_contract_verified (0/1)
// 2. owner() == address(0)         → ownership_renounced  (0/1)
//    (reverts treated as renounced — no owner() = safe)

await db.prepare(`
  UPDATE tokens SET
    is_contract_verified = ?,
    ownership_renounced  = ?,
    contract_safety_at   = datetime('now')
  WHERE address = ?
`).bind(isVerified ? 1 : 0, renounced ? 1 : 0, tokenAddress).run();

-- tokens: one row per tracked token (migrations 0001 + 0003)
CREATE TABLE tokens (
  id                    TEXT PRIMARY KEY,
  address               TEXT UNIQUE NOT NULL,
  symbol                TEXT NOT NULL,
  name                  TEXT NOT NULL,
  deployer_wallet       TEXT,               -- Layer 1: who signed the deploy tx
  pair_address          TEXT,               -- V4 pool ID (32-byte) or V3 LP address
  clanker_id            TEXT,               -- Clanker internal ID (if applicable)
  fee_model             TEXT,               -- 'post_migration' (V4) | 'pre_migration' (V3)
  creator_fee_pct       REAL,               -- creator share (0.5 = 50bp)
  total_fees_accrued    REAL DEFAULT 0,     -- WETH accrued (claimed + unclaimed)
  total_fees_claimed    REAL DEFAULT 0,     -- WETH already claimed
  last_fee_scan         TEXT,               -- ISO datetime of last scan
  price_usd             REAL,
  market_cap_usd        REAL,
  volume_24h_usd        REAL,
  liquidity_usd         REAL,
  twitter_handle        TEXT,               -- Layer 2: feeRecipient Twitter (company/project)
  website_url           TEXT,
  github_url            TEXT,
  is_contract_verified  INTEGER,            -- 1 = Basescan verified
  ownership_renounced   INTEGER,            -- 1 = owner() == address(0)
  fee_accrual_rate_7d   REAL,               -- avg WETH/day over 7 days
  fee_velocity_score    INTEGER,            -- 0-100
  created_at            TEXT DEFAULT (datetime('now')),
  updated_at            TEXT DEFAULT (datetime('now'))
);

-- fee_claims: snapshot per scan cycle where fees ≥ MIN threshold
CREATE TABLE fee_claims (
  id                   TEXT PRIMARY KEY,
  token_address        TEXT NOT NULL,
  developer_id         TEXT,               -- FK → developers.id
  unclaimed_amount_eth REAL NOT NULL,
  unclaimed_amount_usd REAL NOT NULL,
  is_claimed           INTEGER DEFAULT 0,
  claimed_at           TEXT,
  claim_tx_hash        TEXT,
  scanned_at           TEXT DEFAULT (datetime('now')),
  block_number         INTEGER
);