main.go

package main

import (
	"bytes"
	"crypto/tls"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"html/template"
	"io"
	"math/big"
	"net/http"
	"os"
	"sort"
	"strings"
	"time"
)

// ── Contract addresses (Sepolia defaults) ─────────────────────────────────────

const (
	defaultRPC    = "" // must be set via RPC_URL environment variable
	defaultVault  = "0x19ebb35279A16207Ec4ba82799CC64715065F7F6"
	defaultYield  = "0x6aD038cA6C04e885630851278ca0a856Ad9a66Cc"
	defaultNavEng = "0xfEd839B6BA09c1aBf4C768abA0ECA50746E4eca9"
	// FeedVerifier is the oracle the StakingVault actually reads via IFeedVerifier.priceOf(feedId).
	defaultFeedVerifier = "0xdF4ab20fA7752Be52E41e42F1FD667f37964d6a3"
	defaultFeedId       = "0x0007c8ed155d952e003b1e15ce7666fea785cfbe216577d578fce3920e997271"
)

// ── Precomputed event topics and selectors ────────────────────────────────────

const (
	transferTopic = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef"
	// ERC-4626: Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares)
	depositTopic = "0xdcbc1c05240f31ff3ad067ef1ee35ce4997762752e3a095284754544f4c709d7"
	// ERC-4626: Withdraw(address indexed sender, address indexed receiver, address indexed owner, uint256 assets, uint256 shares)
	withdrawTopic = "0xfbde797d201c681b91056529119e0b02407c7bb96a4a2c75c01fc9667232c8db"

	// HastraNavEngine: RateUpdated(int192 indexed rate, uint256 totalSupply, uint256 totalTVL, uint256 indexed timestamp)
	rateUpdatedTopic = "0xce568f0e96595181b7d4a837b062d1daf6c0a1ef743d9ada97f7b9153b34c5b2"
	// HastraNavEngine.getRate() selector = keccak256("getRate()")[0:4]
	getRateSelector = "0x679aefce"
	// IFeedVerifier.priceOf(bytes32) selector = keccak256("priceOf(bytes32)")[0:4]
	// This is what StakingVault.getVerifiedNav() actually calls — the authoritative source.
	priceOfSelector = "0xeec332fd"
)

var (
	rewardsTopic = "0xd08f649d9d8d8398b8cb9f2ba4280f3f688dbc61c92d7d2ef89b1e81f0d71f19"
	zeroTopic    = "0x" + strings.Repeat("0", 64)
	navPrecision = new(big.Int).Exp(big.NewInt(10), big.NewInt(18), nil)
)

// ── Types ─────────────────────────────────────────────────────────────────────

type rpcClient struct {
	url    string
	http   *http.Client
	nextID int
}

type rpcRequest struct {
	JSONRPC string      `json:"jsonrpc"`
	ID      int         `json:"id"`
	Method  string      `json:"method"`
	Params  interface{} `json:"params"`
}

type rpcResponse struct {
	JSONRPC string          `json:"jsonrpc"`
	ID      int             `json:"id"`
	Result  json.RawMessage `json:"result"`
	Error   *rpcError       `json:"error"`
}

type rpcError struct {
	Code    int    `json:"code"`
	Message string `json:"message"`
}

type blockResp struct {
	Timestamp string `json:"timestamp"`
}

type logEntry struct {
	Address         string   `json:"address"`
	Topics          []string `json:"topics"`
	Data            string   `json:"data"`
	BlockNumber     string   `json:"blockNumber"`
	TransactionHash string   `json:"transactionHash"`
	BlockHash       string   `json:"blockHash"`
}

// mintBurnRow is one Deposit or Withdraw with its inline NAV verification.
//
// Column semantics:
//
//	Deposit:  WYLDS = wYLDS deposited (in),    PRIME = PRIME minted,    OracleCalc = oracle-expected PRIME
//	Withdraw: WYLDS = wYLDS returned (out),    PRIME = PRIME burned,    OracleCalc = oracle-expected wYLDS
type mintBurnRow struct {
	Kind        string
	TxHash      string
	Block       uint64
	Timestamp   time.Time
	WYLDS       *big.Int // wYLDS side of the trade
	PRIME       *big.Int // PRIME side of the trade
	FVNav       *big.Int // FeedVerifier.priceOf() at tx block — what the vault actually used
	EngineRate  *big.Int // HastraNavEngine.getRate() at same block
	OracleCalc  *big.Int // oracle-computed counterpart to verify against PRIME (deposit) or WYLDS (withdraw)
	Drift       *big.Int // |OracleCalc - actual output|
	Match       bool
	OracleDelta *big.Int // FeedVerifier - HastraNavEngine (signed, in 1e18 units)
}

// otherRow covers non-deposit/withdraw events shown in the supplementary log.
type otherRow struct {
	Kind      string
	TxHash    string
	Timestamp time.Time
	Details   string
}

// navRateEvent is one RateUpdated emission from HastraNavEngine.
type navRateEvent struct {
	Block     uint64
	Timestamp time.Time
	Rate      *big.Int
	Supply    *big.Int
	TVL       *big.Int
}

// ── Heatmap types ─────────────────────────────────────────────────────────────

const defaultHeatmapAddress = "0x5f134E02dbDd7514E0E166f8D55BB2E6D06659b3"
const heatmapLookbackDays = 90 // rolling window for heatmap

type calendarDay struct {
	Day   int    // 1-31; 0 = empty padding cell
	Count int
	Date  string // "2006-01-02" for tooltip
}

type calendarMonth struct {
	Name  string
	Year  int
	Total int
	Weeks [][]calendarDay // rows of 7 days Mon→Sun
}

const tmplHTML = `
<!DOCTYPE html>
<html>
<head>
    <title>Vault NAV Dashboard</title>
    <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
    <style>
        body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; margin: 20px; background: #0f172a; color: #f8fafc; }
        h1, h2 { color: #38bdf8; }
        table { width: 100%; border-collapse: collapse; margin-top: 20px; font-size: 14px; }
        th, td { border: 1px solid #334155; padding: 10px; text-align: left; }
        th { background: #1e293b; color: #cbd5e1; }
        tr:nth-child(even) { background-color: #0f172a; }
        tr:nth-child(odd) { background-color: #1e293b; }
        .mismatch { color: #ef4444; font-weight: bold; }
        .ok { color: #22c55e; font-weight: bold; }
        .chart-container { width: 100%; height: 500px; margin-bottom: 40px; background: #1e293b; padding: 20px; border-radius: 8px; box-sizing: border-box; }
        .container { max-width: 1200px; margin: 0 auto; }
    </style>
</head>
<body>
    <div class="container">
        <h1>Vault NAV Dashboard</h1>
        <p style="margin-bottom:16px;"><a href="/heatmap" style="color:#38bdf8;text-decoration:none;">📊 Activity Heatmap →</a></p>
        <div class="chart-container">
            <canvas id="navChart"></canvas>
        </div>

        <h2>Mint / Burn Verifications</h2>
        <table>
            <tr>
                <th>Time</th>
                <th>Type</th>
                <th>wYLDS</th>
                <th>PRIME</th>
                <th>FV-NAV</th>
                <th>ENG-NAV</th>
                <th>Oracle Calc</th>
                <th>Drift</th>
                <th>Status</th>
            </tr>
            {{range .MintBurns}}
            <tr>
                <td>{{.Timestamp.Format "2006-01-02 15:04:05"}}</td>
                <td>{{.Kind}}</td>
                <td>{{format6 .WYLDS}}</td>
                <td>{{format6 .PRIME}}</td>
                <td>{{formatNav .FVNav}}</td>
                <td>{{formatNav .EngineRate}}</td>
                <td>{{format6 .OracleCalc}}</td>
                <td>{{format6 .Drift}}</td>
                <td class="{{if .Match}}ok{{else}}mismatch{{end}}">{{if .Match}}OK{{else}}MISMATCH{{end}}</td>
            </tr>
            {{else}}
            <tr>
                <td colspan="9" style="text-align: center;">No mint/burns in this window</td>
            </tr>
            {{end}}
        </table>
    </div>

    <script>
        const ctx = document.getElementById('navChart').getContext('2d');
        const navFullValues = [
            {{range .NavRates}}'{{formatNavFull .Rate}}',{{end}}
        ];
        const data = {
            labels: [
                {{range .NavRates}}'{{.Timestamp.Format "Jan 02 15:04"}}',{{end}}
            ],
            datasets: [{
                label: 'NAV Rate (HastraNavEngine)',
                data: [
                    {{range .NavRates}}{{formatNavFloat .Rate}},{{end}}
                ],
                borderColor: '#38bdf8',
                backgroundColor: 'rgba(56, 189, 248, 0.2)',
                borderWidth: 2,
                pointBackgroundColor: '#38bdf8',
                tension: 0.3,
                fill: true
            }]
        };
        new Chart(ctx, {
            type: 'line',
            data: data,
            options: {
                responsive: true,
                maintainAspectRatio: false,
                plugins: {
                    legend: { labels: { color: '#f8fafc' } },
                    tooltip: {
                        callbacks: {
                            label: function(context) {
                                return 'NAV: ' + navFullValues[context.dataIndex];
                            }
                        }
                    }
                },
                scales: {
                    x: {
                        ticks: { color: '#cbd5e1' },
                        grid: { color: '#334155' }
                    },
                    y: {
                        ticks: {
                            color: '#cbd5e1',
                            callback: function(value) {
                                return parseFloat(value).toFixed(18);
                            }
                        },
                        grid: { color: '#334155' }
                    }
                }
            }
        });
    </script>
</body>
</html>
`

// ── Activity page HTML template ───────────────────────────────────────────────

const heatmapHTML = `
<!DOCTYPE html>
<html>
<head>
    <title>Address Activity</title>
    <style>
        * { box-sizing: border-box; }
        body { font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif; margin: 20px; background: #0f172a; color: #f8fafc; }
        h1, h2 { color: #38bdf8; }
        a { color: #38bdf8; text-decoration: none; }
        a:hover { text-decoration: underline; }
        .container { max-width: 1400px; margin: 0 auto; }
        .address-form { display: flex; gap: 10px; align-items: center; margin: 20px 0; flex-wrap: wrap; }
        .address-form input {
            flex: 1; min-width: 380px; padding: 10px 14px;
            background: #1e293b; border: 1px solid #334155; border-radius: 6px;
            color: #f8fafc; font-size: 14px; font-family: monospace;
        }
        .address-form input:focus { outline: none; border-color: #38bdf8; }
        .address-form button {
            padding: 10px 22px; background: #0284c7; border: none; border-radius: 6px;
            color: white; font-size: 14px; cursor: pointer;
        }
        .address-form button:hover { background: #0369a1; }
        .meta { color: #94a3b8; font-size: 13px; margin: 6px 0; }
        .badge { background: #1e293b; border: 1px solid #334155; border-radius: 4px; padding: 3px 10px; font-size: 12px; color: #94a3b8; margin-right: 6px; }
        table { width: 100%; border-collapse: collapse; margin-top: 16px; font-size: 13px; }
        th, td { border: 1px solid #334155; padding: 9px 12px; text-align: left; }
        th { background: #1e293b; color: #cbd5e1; white-space: nowrap; }
        tr:nth-child(even)  { background: #0f172a; }
        tr:nth-child(odd)   { background: #1e293b; }
        .mono { font-family: monospace; font-size: 12px; }
        .tag { display: inline-block; padding: 2px 8px; border-radius: 4px; font-size: 11px; font-weight: bold; }
        .tag-deposit  { background: #14532d; color: #86efac; }
        .tag-withdraw { background: #7c2d12; color: #fdba74; }
        .tag-transfer { background: #1e3a5f; color: #93c5fd; }
        .tag-rewards  { background: #3b0764; color: #d8b4fe; }
        .tag-other    { background: #1e293b; color: #94a3b8; }
        .error { color: #ef4444; margin: 20px 0; }
        .note { background: #1e293b; border: 1px solid #334155; border-radius: 6px; padding: 12px 16px; margin: 16px 0; font-size: 12px; color: #94a3b8; }
        .note strong { color: #cbd5e1; }
        .empty-msg { color: #64748b; text-align: center; padding: 40px; }
    </style>
</head>
<body>
<div class="container">
    <h1>Address Activity</h1>
    <p><a href="/">← Back to NAV Dashboard</a></p>

    <form class="address-form" method="GET" action="/heatmap">
        <input type="text" name="address" placeholder="0x..." value="{{.Address}}" spellcheck="false" autocomplete="off" />
        <button type="submit">Load</button>
    </form>

    <div class="note">
        <strong>Scanning:</strong> Vault &amp; YieldVault contracts for
        <span class="tag tag-deposit">Deposit</span>
        <span class="tag tag-withdraw">Withdraw</span>
        <span class="tag tag-transfer">Transfer</span>
        <span class="tag tag-rewards">Rewards</span>
        events where this address appears in any topic.
        Lookback: <strong>last {{.Days}} days</strong> (~{{.BlocksBack}} blocks).
    </div>

    {{if .Error}}
        <p class="error">⚠ {{.Error}}</p>
    {{else}}
        <p class="meta">
            <span class="badge">{{len .Events}} events found</span>
            Address: <span class="mono">{{.Address}}</span>
        </p>

        <table>
            <tr>
                <th>Date (UTC)</th>
                <th>Block</th>
                <th>Tx Hash</th>
                <th>Contract</th>
                <th>Event</th>
                <th>From / Sender</th>
                <th>To / Receiver</th>
                <th>Assets</th>
                <th>Shares</th>
            </tr>
            {{range .Events}}
            <tr>
                <td class="mono">{{.Timestamp.Format "2006-01-02 15:04"}}</td>
                <td class="mono">{{.Block}}</td>
                <td class="mono"><a href="https://etherscan.io/tx/{{.TxHash}}" target="_blank">{{slice .TxHash 0 10}}…</a></td>
                <td>{{.ContractLabel}}</td>
                <td><span class="tag tag-{{.EventClass}}">{{.EventType}}</span></td>
                <td class="mono">{{if .From}}<a href="https://etherscan.io/address/{{.From}}" target="_blank">{{slice .From 0 10}}…</a>{{end}}</td>
                <td class="mono">{{if .To}}<a href="https://etherscan.io/address/{{.To}}" target="_blank">{{slice .To 0 10}}…</a>{{end}}</td>
                <td class="mono">{{.Assets}}</td>
                <td class="mono">{{.Shares}}</td>
            </tr>
            {{else}}
            <tr><td colspan="9" class="empty-msg">No events found for this address in the last {{.Days}} days.</td></tr>
            {{end}}
        </table>
    {{end}}
</div>
</body>
</html>
`

// ── main ─────────────────────────────────────────────────────────────────────

func main() {
	rpcURL := os.Getenv("RPC_URL")
	if rpcURL == "" {
		fatal("RPC_URL environment variable is required")
	}
	vault := strings.ToLower(getenv("VAULT_ADDRESS", defaultVault))
	yieldVault := strings.ToLower(getenv("YIELD_VAULT_ADDRESS", defaultYield))
	navEngine := strings.ToLower(getenv("NAV_ENGINE_ADDRESS", defaultNavEng))
	feedVerifier := strings.ToLower(getenv("FEED_VERIFIER_ADDRESS", defaultFeedVerifier))
	feedId := getenv("NAV_FEED_ID", defaultFeedId)

	// Window resolution order:
	//   1. START_UTC + END_UTC (RFC3339) — explicit range
	//   2. WINDOW_HOURS (integer) — rolling window ending now, default 24
	end := time.Now().UTC()
	windowHours := 128
	if h := os.Getenv("WINDOW_HOURS"); h != "" {
		n := 0
		_, _ = fmt.Sscanf(h, "%d", &n)
		if n <= 0 {
			fatal("WINDOW_HOURS must be a positive integer")
		}
		windowHours = n
	}
	start := end.Add(-time.Duration(windowHours) * time.Hour)
	if s := os.Getenv("START_UTC"); s != "" {
		t, err := time.Parse(time.RFC3339, s)
		if err != nil {
			fatal("invalid START_UTC: %v", err)
		}
		start = t
	}
	if e := os.Getenv("END_UTC"); e != "" {
		t, err := time.Parse(time.RFC3339, e)
		if err != nil {
			fatal("invalid END_UTC: %v", err)
		}
		end = t
	}
	if !end.After(start) {
		fatal("END_UTC must be after START_UTC")
	}

	client := &rpcClient{
		url: rpcURL,
		http: &http.Client{
			Timeout: 30 * time.Second,
			Transport: &http.Transport{
				TLSClientConfig: &tls.Config{MinVersion: tls.VersionTLS12},
			},
		},
	}

	startBlock, endBlock, err := locateBlockRange(client, start.Unix(), end.Unix())
	if err != nil {
		fatal("locate block range: %v", err)
	}

	fmt.Printf("RPC:          %s\n", rpcURL)
	fmt.Printf("Vault:        %s\n", vault)
	fmt.Printf("YieldVault:   %s\n", yieldVault)
	fmt.Printf("NavEngine:    %s\n", navEngine)
	fmt.Printf("FeedVerifier: %s\n", feedVerifier)
	fmt.Printf("FeedId:       %s\n", feedId)
	fmt.Printf("Window:       %s  ->  %s\n", start.Format(time.RFC3339), end.Format(time.RFC3339))
	fmt.Printf("Blocks:       %d  ->  %d\n\n", startBlock, endBlock)

	// ── Collect data ──────────────────────────────────────────────────────────
	mintBurns, err := collectMintBurns(client, vault, feedVerifier, feedId, navEngine, startBlock, endBlock)
	if err != nil {
		fatal("collect mint/burns: %v", err)
	}
	navRates, err := collectNavRates(client, navEngine, startBlock, endBlock)
	if err != nil {
		fatal("collect nav rates: %v", err)
	}
	others, err := collectOtherEvents(client, vault, yieldVault, startBlock, endBlock)
	if err != nil {
		fatal("collect other events: %v", err)
	}

	fmt.Printf("Collected %d mint/burns, %d nav rates, %d other events.\n", len(mintBurns), len(navRates), len(others))

	// ── Web Dashboard GUI ──────────────────────────────────────────
	fmt.Println("\n======================================================================")
	fmt.Println(" Starting Web Dashboard GUI on http://localhost:8080")
	fmt.Println(" Open your browser to view the graph and table!")
	fmt.Println(" Press Ctrl+C to stop")
	fmt.Println("======================================================================")

	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
		tmpl, err := template.New("dashboard").Funcs(template.FuncMap{
			"format6":   format6,
			"formatNav": formatNav,
			"formatNavFloat": func(v *big.Int) float64 {
				if v == nil {
					return 0
				}
				f := new(big.Float).SetInt(v)
				p := new(big.Float).SetInt(navPrecision)
				val, _ := new(big.Float).Quo(f, p).Float64()
				return val
			},
			"formatNavFull": formatNav, // exact 18-decimal string for display
		}).Parse(tmplHTML)

		if err != nil {
			http.Error(w, "Template error: "+err.Error(), http.StatusInternalServerError)
			return
		}

		data := struct {
			MintBurns []mintBurnRow
			NavRates  []navRateEvent
			Others    []otherRow
		}{
			MintBurns: mintBurns,
			NavRates:  navRates,
			Others:    others,
		}

		w.Header().Set("Content-Type", "text/html; charset=utf-8")
		if err := tmpl.Execute(w, data); err != nil {
			fmt.Printf("Template execute error: %v\n", err)
		}
	})

	// ── Address activity handler ──────────────────────────────────────────────
	http.HandleFunc("/heatmap", func(w http.ResponseWriter, r *http.Request) {
		addr := r.URL.Query().Get("address")
		if addr == "" {
			addr = defaultHeatmapAddress
		}

		blocksBack := uint64(heatmapLookbackDays) * 24 * 300

		type pageData struct {
			Address       string
			Days          int
			BlocksBack    uint64
			Events        []activityRow
			Error         string
		}

		tmpl, err := template.New("heatmap").Funcs(template.FuncMap{
			"slice": func(s string, i, j int) string {
				if j > len(s) {
					j = len(s)
				}
				return s[i:j]
			},
		}).Parse(heatmapHTML)
		if err != nil {
			http.Error(w, err.Error(), http.StatusInternalServerError)
			return
		}
		w.Header().Set("Content-Type", "text/html; charset=utf-8")

		events, err := collectAddressActivity(client, addr, vault, yieldVault, heatmapLookbackDays)
		if err != nil {
			_ = tmpl.Execute(w, pageData{Address: addr, Days: heatmapLookbackDays, BlocksBack: blocksBack, Error: err.Error()})
			return
		}

		if err := tmpl.Execute(w, pageData{
			Address:    addr,
			Days:       heatmapLookbackDays,
			BlocksBack: blocksBack,
			Events:     events,
		}); err != nil {
			fmt.Printf("heatmap template error: %v\n", err)
		}
	})

	port := getenv("PORT", "8080")
	fmt.Printf("Listening on :%s\n", port)
	if err := http.ListenAndServe(":"+port, nil); err != nil {
		fmt.Printf("HTTP server error: %v\n", err)
	}
}

// ── Heatmap / address activity ────────────────────────────────────────────────

// activityRow is one vault event involving the queried address.
type activityRow struct {
	TxHash        string
	Block         uint64
	Timestamp     time.Time
	ContractLabel string // "Vault" or "YieldVault"
	EventType     string // "Deposit", "Withdraw", "Transfer", "Rewards"
	EventClass    string // css class suffix
	From          string // full address
	To            string
	Assets        string
	Shares        string
}

// collectAddressActivity fetches all vault/yieldVault events involving addr
// over the last lookbackDays days and returns them sorted by block ascending.
func collectAddressActivity(client *rpcClient, addr, vault, yieldVault string, lookbackDays int) ([]activityRow, error) {
	addr = strings.ToLower(addr)
	paddedAddr := "0x" + strings.Repeat("0", 24) + strings.TrimPrefix(addr, "0x")

	// Get latest block (no binary search needed)
	raw, err := client.call("eth_blockNumber", []interface{}{})
	if err != nil {
		return nil, fmt.Errorf("eth_blockNumber: %w", err)
	}
	var latestHex string
	if err := json.Unmarshal(raw, &latestHex); err != nil {
		return nil, err
	}
	latest, _ := hexToUint64(latestHex)

	blocksBack := uint64(lookbackDays) * 24 * 300
	startBlock := uint64(0)
	if latest > blocksBack {
		startBlock = latest - blocksBack
	}
	startTime := time.Now().Add(-time.Duration(lookbackDays) * 24 * time.Hour)

	allTopics := []interface{}{
		[]string{transferTopic, depositTopic, withdrawTopic, rewardsTopic},
	}

	contractMap := map[string]string{
		vault:      "Vault",
		yieldVault: "YieldVault",
	}

	// Collect unique blocks we need timestamps for
	blockTimes := make(map[uint64]time.Time)

	var raw2 []logEntry
	for contract, label := range contractMap {
		logs, err := client.logs(startBlock, latest, contract, allTopics)
		if err != nil {
			return nil, fmt.Errorf("logs for %s (%s): %w", label, contract, err)
		}
		raw2 = append(raw2, logs...)
	}

	// Filter events that involve the target address
	var matched []logEntry
	for _, lg := range raw2 {
		for _, t := range lg.Topics {
			if strings.EqualFold(t, paddedAddr) {
				matched = append(matched, lg)
				bn, _ := hexToUint64(lg.BlockNumber)
				blockTimes[bn] = time.Time{} // mark for timestamp fetch
				break
			}
		}
	}

	// Fetch timestamps for unique blocks (small set)
	for bn := range blockTimes {
		ts, err := client.blockTimestamp(bn)
		if err != nil {
			// Fall back to interpolation
			blockTimes[bn] = interpolateBlockDate(bn, startBlock, latest, startTime, time.Now())
		} else {
			blockTimes[bn] = time.Unix(ts, 0).UTC()
		}
	}

	// Build rows
	var rows []activityRow
	seen := make(map[string]bool) // deduplicate same txhash+topic
	for _, lg := range matched {
		bn, _ := hexToUint64(lg.BlockNumber)
		key := lg.TransactionHash + lg.Topics[0]
		if seen[key] {
			continue
		}
		seen[key] = true

		label := contractMap[strings.ToLower(lg.Address)]

		var evType, evClass string
		var from, to, assets, shares string
		switch lg.Topics[0] {
		case depositTopic:
			evType, evClass = "Deposit", "deposit"
			if len(lg.Topics) > 1 {
				from = topicToAddr(lg.Topics[1])
			}
			if len(lg.Topics) > 2 {
				to = topicToAddr(lg.Topics[2])
			}
			assets = formatTokenAmount(parseWord(lg.Data, 0))
			shares = formatTokenAmount(parseWord(lg.Data, 1))
		case withdrawTopic:
			evType, evClass = "Withdraw", "withdraw"
			if len(lg.Topics) > 1 {
				from = topicToAddr(lg.Topics[1])
			}
			if len(lg.Topics) > 2 {
				to = topicToAddr(lg.Topics[2])
			}
			assets = formatTokenAmount(parseWord(lg.Data, 0))
			shares = formatTokenAmount(parseWord(lg.Data, 1))
		case transferTopic:
			evType, evClass = "Transfer", "transfer"
			if len(lg.Topics) > 1 {
				from = topicToAddr(lg.Topics[1])
			}
			if len(lg.Topics) > 2 {
				to = topicToAddr(lg.Topics[2])
			}
			shares = formatTokenAmount(parseWord(lg.Data, 0))
		default:
			evType, evClass = "Rewards", "rewards"
		}

		rows = append(rows, activityRow{
			TxHash:        lg.TransactionHash,
			Block:         bn,
			Timestamp:     blockTimes[bn],
			ContractLabel: label,
			EventType:     evType,
			EventClass:    evClass,
			From:          from,
			To:            to,
			Assets:        assets,
			Shares:        shares,
		})
	}

	sort.Slice(rows, func(i, j int) bool { return rows[i].Block < rows[j].Block })
	return rows, nil
}

// topicToAddr extracts a checksummed-ish address from a 32-byte topic.
func topicToAddr(topic string) string {
	if len(topic) < 42 {
		return topic
	}
	return "0x" + topic[len(topic)-40:]
}

// formatTokenAmount renders a raw 18-decimal big.Int as a readable string.
func formatTokenAmount(v *big.Int) string {
	if v == nil {
		return ""
	}
	whole := new(big.Int).Div(new(big.Int).Set(v), navPrecision)
	frac := new(big.Int).Mod(new(big.Int).Set(v), navPrecision)
	fracStr := fmt.Sprintf("%018d", frac)
	// Trim trailing zeros for readability
	fracStr = strings.TrimRight(fracStr, "0")
	if fracStr == "" {
		return whole.String()
	}
	return whole.String() + "." + fracStr
}

// interpolateBlockDate estimates the date of a block by linear interpolation.
func interpolateBlockDate(blockNum, startBlock, endBlock uint64, startTime, endTime time.Time) time.Time {
	if endBlock <= startBlock {
		return startTime
	}
	ratio := float64(blockNum-startBlock) / float64(endBlock-startBlock)
	return startTime.Add(time.Duration(float64(endTime.Sub(startTime)) * ratio))
}

// ── Heatmap / address activity ────────────────────────────────────────────────

// ── Data collection ───────────────────────────────────────────────────────────

// collectMintBurns fetches Deposit and Withdraw events, then for each one calls
// FeedVerifier.priceOf(feedId) at that exact block — the same oracle path the vault uses.
// It also calls HastraNavEngine.getRate() at the same block to show oracle divergence.
func collectMintBurns(client *rpcClient, vault, feedVerifier, feedId, navEngine string, startBlock, endBlock uint64) ([]mintBurnRow, error) {
	var rows []mintBurnRow

	deps, err := client.logs(startBlock, endBlock, vault, []interface{}{depositTopic})
	if err != nil {
		return nil, err
	}
	for _, e := range deps {
		row, err := buildMintBurnRow(client, feedVerifier, feedId, navEngine, e, "Deposit")
		if err != nil {
			return nil, err
		}
		rows = append(rows, row)
	}

	withs, err := client.logs(startBlock, endBlock, vault, []interface{}{withdrawTopic})
	if err != nil {
		return nil, err
	}
	for _, e := range withs {
		row, err := buildMintBurnRow(client, feedVerifier, feedId, navEngine, e, "Withdraw")
		if err != nil {
			return nil, err
		}
		rows = append(rows, row)
	}

	sort.Slice(rows, func(i, j int) bool { return rows[i].Timestamp.Before(rows[j].Timestamp) })
	return rows, nil
}

func buildMintBurnRow(client *rpcClient, feedVerifier, feedId, navEngineAddr string, e logEntry, kind string) (mintBurnRow, error) {
	ts, err := client.blockTime(e.BlockHash)
	if err != nil {
		return mintBurnRow{}, err
	}
	bn, _ := hexToUint64(e.BlockNumber)

	// ERC-4626 Deposit / Withdraw event data layout: [assets uint256][shares uint256]
	assets := parseWord(e.Data, 0)
	shares := parseWord(e.Data, 1)

	// Query FeedVerifier.priceOf(feedId) — the same call StakingVault.getVerifiedNav() makes.
	nav, err := client.callPriceOf(bn, feedVerifier, feedId)
	if err != nil {
		return mintBurnRow{}, fmt.Errorf("priceOf at block %d: %w", bn, err)
	}

	// Also query HastraNavEngine.getRate() at the same block to show oracle divergence.
	engineRate, err := client.callGetRate(bn, navEngineAddr)
	if err != nil {
		engineRate = big.NewInt(0) // non-fatal: show zero if unavailable
	}
	oracleDelta := new(big.Int).Sub(nav, engineRate) // signed: FeedVerifier - NavEngine

	// Assign wYLDS and PRIME sides, and compute oracle-expected counterpart.
	var wylds, prime, oracleCalc *big.Int
	if kind == "Deposit" {
		wylds = assets // wYLDS deposited
		prime = shares // PRIME minted
		if nav.Sign() > 0 {
			// oracle says: PRIME_calc = wYLDS * 1e18 / nav
			oracleCalc = new(big.Int).Div(new(big.Int).Mul(assets, navPrecision), nav)
		}
	} else {
		wylds = assets // wYLDS returned
		prime = shares // PRIME burned
		if nav.Sign() > 0 {
			// oracle says: wYLDS_calc = PRIME * nav / 1e18
			oracleCalc = new(big.Int).Div(new(big.Int).Mul(shares, nav), navPrecision)
		}
	}

	// For drift: Deposit checks PRIME minted vs oracle-calc PRIME.
	//            Withdraw checks wYLDS returned vs oracle-calc wYLDS.
	var actual *big.Int
	if kind == "Deposit" {
		actual = prime
	} else {
		actual = wylds
	}

	drift := new(big.Int)
	match := false
	if oracleCalc != nil {
		drift = new(big.Int).Abs(new(big.Int).Sub(oracleCalc, actual))
		match = drift.Cmp(big.NewInt(1)) <= 0 // +-1 unit rounding tolerance
	}

	return mintBurnRow{
		Kind: kind, TxHash: e.TransactionHash, Block: bn, Timestamp: ts,
		WYLDS: wylds, PRIME: prime, FVNav: nav, EngineRate: engineRate,
		OracleCalc: oracleCalc, Drift: drift, Match: match, OracleDelta: oracleDelta,
	}, nil
}

// collectNavRates fetches RateUpdated events from HastraNavEngine.
func collectNavRates(client *rpcClient, navEngine string, startBlock, endBlock uint64) ([]navRateEvent, error) {
	entries, err := client.logs(startBlock, endBlock, navEngine, []interface{}{rateUpdatedTopic})
	if err != nil {
		return nil, err
	}
	var result []navRateEvent
	for _, e := range entries {
		ts, err := client.blockTime(e.BlockHash)
		if err != nil {
			return nil, err
		}
		bn, _ := hexToUint64(e.BlockNumber)
		// RateUpdated layout: topics[1]=rate (int192 indexed), topics[2]=timestamp (indexed)
		//                     data word 0=totalSupply, data word 1=totalTVL
		result = append(result, navRateEvent{
			Block:     bn,
			Timestamp: ts,
			Rate:      hexToBig(e.Topics[1]),
			Supply:    parseWord(e.Data, 0),
			TVL:       parseWord(e.Data, 1),
		})
	}
	return result, nil
}

// collectOtherEvents gathers PRIME mints/burns, wYLDS transfers, and reward events.
func collectOtherEvents(client *rpcClient, vault, yieldVault string, startBlock, endBlock uint64) ([]otherRow, error) {
	var rows []otherRow

	add := func(entries []logEntry, kind string, detail func(logEntry) string) error {
		for _, e := range entries {
			ts, err := client.blockTime(e.BlockHash)
			if err != nil {
				return err
			}
			rows = append(rows, otherRow{Kind: kind, TxHash: e.TransactionHash, Timestamp: ts, Details: detail(e)})
		}
		return nil
	}

	mints, err := client.logs(startBlock, endBlock, vault, []interface{}{transferTopic, zeroTopic})
	if err != nil {
		return nil, err
	}
	if err := add(mints, "PRIME Mint", func(e logEntry) string {
		return fmt.Sprintf("to=%s amount=%s", topicAddress(e.Topics[2]), format6(hexToBig(e.Data)))
	}); err != nil {
		return nil, err
	}

	burns, err := client.logs(startBlock, endBlock, vault, []interface{}{transferTopic, nil, zeroTopic})
	if err != nil {
		return nil, err
	}
	if err := add(burns, "PRIME Burn", func(e logEntry) string {
		return fmt.Sprintf("from=%s amount=%s", topicAddress(e.Topics[1]), format6(hexToBig(e.Data)))
	}); err != nil {
		return nil, err
	}

	wIn, err := client.logs(startBlock, endBlock, yieldVault, []interface{}{transferTopic, nil, addressTopic(vault)})
	if err != nil {
		return nil, err
	}
	if err := add(wIn, "wYLDS In", func(e logEntry) string {
		return fmt.Sprintf("from=%s amount=%s", topicAddress(e.Topics[1]), format6(hexToBig(e.Data)))
	}); err != nil {
		return nil, err
	}

	wOut, err := client.logs(startBlock, endBlock, yieldVault, []interface{}{transferTopic, addressTopic(vault)})
	if err != nil {
		return nil, err
	}
	if err := add(wOut, "wYLDS Out", func(e logEntry) string {
		return fmt.Sprintf("to=%s amount=%s", topicAddress(e.Topics[2]), format6(hexToBig(e.Data)))
	}); err != nil {
		return nil, err
	}

	rwds, err := client.logs(startBlock, endBlock, vault, []interface{}{rewardsTopic})
	if err != nil {
		return nil, err
	}
	if err := add(rwds, "RewardsDistributed", func(e logEntry) string {
		return fmt.Sprintf("amount=%s", format6(parseWord(e.Data, 0)))
	}); err != nil {
		return nil, err
	}

	return rows, nil
}

// ── RPC helpers ───────────────────────────────────────────────────────────────

// callPriceOf calls FeedVerifier.priceOf(feedId) at a specific block via eth_call.
// This is the authoritative oracle path: StakingVault.getVerifiedNav() → IFeedVerifier.priceOf(navFeedId).
func (c *rpcClient) callPriceOf(blockNum uint64, feedVerifier, feedId string) (*big.Int, error) {
	// ABI-encode priceOf(bytes32): selector (4 bytes) + feedId (32 bytes, no padding needed)
	clean := strings.TrimPrefix(feedId, "0x")
	if len(clean) != 64 {
		return nil, fmt.Errorf("invalid feedId length: %d", len(clean))
	}
	data := priceOfSelector + clean
	payload, err := c.call("eth_call", []interface{}{
		map[string]string{"to": feedVerifier, "data": data},
		fmt.Sprintf("0x%x", blockNum),
	})
	if err != nil {
		return nil, err
	}
	var hexVal string
	if err := json.Unmarshal(payload, &hexVal); err != nil {
		return nil, err
	}
	if hexVal == "0x" || hexVal == "" {
		return big.NewInt(0), nil
	}
	return hexToBig(hexVal), nil
}

// callGetRate calls HastraNavEngine.getRate() at a specific block via eth_call.
func (c *rpcClient) callGetRate(blockNum uint64, navEngine string) (*big.Int, error) {
	payload, err := c.call("eth_call", []interface{}{
		map[string]string{"to": navEngine, "data": getRateSelector},
		fmt.Sprintf("0x%x", blockNum),
	})
	if err != nil {
		return nil, err
	}
	var hexVal string
	if err := json.Unmarshal(payload, &hexVal); err != nil {
		return nil, err
	}
	if hexVal == "0x" || hexVal == "" {
		return big.NewInt(0), nil
	}
	return hexToBig(hexVal), nil
}

func locateBlockRange(client *rpcClient, startTS, endTS int64) (uint64, uint64, error) {
	raw, err := client.call("eth_blockNumber", []interface{}{})
	if err != nil {
		return 0, 0, err
	}
	var latestHex string
	if err := json.Unmarshal(raw, &latestHex); err != nil {
		return 0, 0, err
	}
	latest, err := hexToUint64(latestHex)
	if err != nil {
		return 0, 0, err
	}
	startB, err := lowerBoundBlock(client, latest, startTS)
	if err != nil {
		return 0, 0, err
	}
	endExcl, err := upperBoundBlock(client, startB, latest, endTS)
	if err != nil {
		return 0, 0, err
	}
	endB := endExcl
	if endExcl > 0 {
		endB = endExcl - 1
	}
	if endB < startB {
		endB = startB
	}
	return startB, endB, nil
}

func lowerBoundBlock(client *rpcClient, latest uint64, target int64) (uint64, error) {
	// Estimate starting point: ~12s per block on mainnet, 3x safety margin
	windowSecs := time.Now().Unix() - target + 7200
	blocksBack := uint64(windowSecs/12) * 3
	lo := uint64(0)
	if latest > blocksBack {
		lo = latest - blocksBack
	}
	hi := latest
	for lo < hi {
		mid := (lo + hi) / 2
		ts, err := client.blockTimestamp(mid)
		if err != nil {
			return 0, err
		}
		if ts < target {
			lo = mid + 1
		} else {
			hi = mid
		}
	}
	return lo, nil
}

func upperBoundBlock(client *rpcClient, start, latest uint64, target int64) (uint64, error) {
	lo, hi := start, latest
	for lo < hi {
		mid := (lo + hi) / 2
		ts, err := client.blockTimestamp(mid)
		if err != nil {
			return 0, err
		}
		if ts <= target {
			lo = mid + 1
		} else {
			hi = mid
		}
	}
	return lo, nil
}

func (c *rpcClient) blockTimestamp(blockNumber uint64) (int64, error) {
	time.Sleep(100 * time.Millisecond) // avoid rate limiting on free-tier RPCs
	payload, err := c.call("eth_getBlockByNumber", []interface{}{fmt.Sprintf("0x%x", blockNumber), false})
	if err != nil {
		return 0, err
	}
	var b blockResp
	if err := json.Unmarshal(payload, &b); err != nil {
		return 0, err
	}
	if b.Timestamp == "" {
		return 0, errors.New("missing block timestamp")
	}
	ts, err := hexToUint64(b.Timestamp)
	return int64(ts), err
}

func (c *rpcClient) blockTime(blockHash string) (time.Time, error) {
	payload, err := c.call("eth_getBlockByHash", []interface{}{blockHash, false})
	if err != nil {
		return time.Time{}, err
	}
	var b blockResp
	if err := json.Unmarshal(payload, &b); err != nil {
		return time.Time{}, err
	}
	ts, err := hexToUint64(b.Timestamp)
	if err != nil {
		return time.Time{}, err
	}
	return time.Unix(int64(ts), 0).UTC(), nil
}

const logsChunkSize = uint64(9_999) // stay under 10k limit

func (c *rpcClient) logs(startBlock, endBlock uint64, address string, topics []interface{}) ([]logEntry, error) {
	var all []logEntry
	for lo := startBlock; lo <= endBlock; lo += logsChunkSize + 1 {
		hi := lo + logsChunkSize
		if hi > endBlock {
			hi = endBlock
		}
		chunk, err := c.logsChunk(lo, hi, address, topics)
		if err != nil {
			return nil, err
		}
		all = append(all, chunk...)
	}
	return all, nil
}

func (c *rpcClient) logsChunk(startBlock, endBlock uint64, address string, topics []interface{}) ([]logEntry, error) {
	payload, err := c.call("eth_getLogs", []interface{}{map[string]interface{}{
		"fromBlock": fmt.Sprintf("0x%x", startBlock),
		"toBlock":   fmt.Sprintf("0x%x", endBlock),
		"address":   address,
		"topics":    topics,
	}})
	if err != nil {
		return nil, err
	}
	var entries []logEntry
	return entries, json.Unmarshal(payload, &entries)
}

func (c *rpcClient) call(method string, params []interface{}) (json.RawMessage, error) {
	const maxRetries = 5
	delay := 500 * time.Millisecond
	for attempt := 0; attempt < maxRetries; attempt++ {
		c.nextID++
		body, err := json.Marshal(rpcRequest{JSONRPC: "2.0", ID: c.nextID, Method: method, Params: params})
		if err != nil {
			return nil, err
		}
		resp, err := c.http.Post(c.url, "application/json", bytes.NewReader(body))
		if err != nil {
			return nil, err
		}
		data, readErr := io.ReadAll(resp.Body)
		_ = resp.Body.Close()
		if readErr != nil {
			return nil, readErr
		}
		if resp.StatusCode == 429 {
			fmt.Printf("rate limited, retrying in %s...\n", delay)
			time.Sleep(delay)
			delay *= 2
			continue
		}
		if resp.StatusCode >= 300 {
			return nil, fmt.Errorf("rpc status %s: %s", resp.Status, strings.TrimSpace(string(data)))
		}
		var decoded rpcResponse
		if err := json.Unmarshal(data, &decoded); err != nil {
			return nil, err
		}
		if decoded.Error != nil {
			return nil, fmt.Errorf("rpc error %d: %s", decoded.Error.Code, decoded.Error.Message)
		}
		return decoded.Result, nil
	}
	return nil, fmt.Errorf("rpc %s: exceeded %d retries due to rate limiting", method, maxRetries)
}

// ── Formatting helpers ────────────────────────────────────────────────────────

// format6 renders a 6-decimal raw integer (e.g. USDC/wYLDS units) as "whole.frac".
func format6(v *big.Int) string {
	if v == nil {
		return "n/a"
	}
	denom := big.NewInt(1_000_000)
	whole := new(big.Int).Div(new(big.Int).Set(v), denom)
	frac := new(big.Int).Mod(new(big.Int).Set(v), denom)
	return fmt.Sprintf("%s.%06s", whole, frac)
}

// formatNav renders a 1e18-scaled NAV as a full 18-decimal string.
func formatNav(v *big.Int) string {
	if v == nil {
		return "n/a"
	}
	whole := new(big.Int).Div(new(big.Int).Set(v), navPrecision)
	frac := new(big.Int).Mod(new(big.Int).Set(v), navPrecision)
	return fmt.Sprintf("%s.%018s", whole, frac)
}

// ── Encoding helpers ──────────────────────────────────────────────────────────

func parseWord(data string, index int) *big.Int {
	clean := strings.TrimPrefix(data, "0x")
	start, end := index*64, (index+1)*64
	if len(clean) < end {
		return big.NewInt(0)
	}
	return hexToBig("0x" + clean[start:end])
}

func hexToBig(value string) *big.Int {
	result := new(big.Int)
	result.SetString(strings.TrimPrefix(value, "0x"), 16)
	return result
}

func hexToUint64(value string) (uint64, error) {
	parsed, ok := new(big.Int).SetString(strings.TrimPrefix(value, "0x"), 16)
	if !ok {
		return 0, fmt.Errorf("invalid hex %q", value)
	}
	return parsed.Uint64(), nil
}

func addressTopic(addr string) string {
	return "0x" + strings.Repeat("0", 24) + strings.TrimPrefix(strings.ToLower(addr), "0x")
}

func topicAddress(topic string) string {
	clean := strings.TrimPrefix(topic, "0x")
	if len(clean) < 40 {
		return "0x" + clean
	}
	return "0x" + clean[len(clean)-40:]
}

func getenv(key, fallback string) string {
	if v := os.Getenv(key); v != "" {
		return v
	}
	return fallback
}

func fatal(format string, args ...interface{}) {
	_, _ = fmt.Fprintf(os.Stderr, format+"\n", args...)
	os.Exit(1)
}

// suppress unused import warning from linters
func init() { _ = hex.EncodeToString }