# v2 git bundle 186c8f06134f468826486c4f2df28746781cb31d refs/heads/bundle 186c8f06134f468826486c4f2df28746781cb31d HEAD PACK7Zx]tree 1a8a16e947f9ef94894b5649c6829d2e1fdc219b parent ffbf00c5240a05797c914d1c26311062afa2c166 author Zach Kelling 1786667698 -0700 committer Zach Kelling 1786667698 -0700 Route a swap on the chain its quote was priced on A quote states the chain it came from, and the dispatcher read that last. A query parameter, or a chainId sitting beside the quote rather than inside it, could send someone's quote to another chain's router — and these chains share deployment addresses, so the same numbers name real pools on the destination. The narrowest statement wins now: the quote's own chain, then the body, then the URL. The handler refuses a foreign quote as well, so neither layer is load bearing alone. Whether a chain can build a swap is one question asked in one place. Both the router and the wrapped native become a twenty-byte argument, so a blank or malformed one produced a call whose arguments had slid; a chain missing either serves no swap route rather than an unsignable one. A chain may declare more than one subgraph holding a book, each in its own goroutine, so the book behind the unprefixed routes was whichever registered last — a different one across restarts. The config names it now. The dispatcher buffered ten times what the handlers will read, and called an oversized body malformed JSON. It reads their limit and says which failure it was. Co-authored-by: Hanzo Dev 3/x/tree e9d597937b672c6e0183fdb62de1b06d5e410f31 parent 8f5f8079040a3ce1b7ffb9f4d7969913e72c498d author Zach Kelling 1786666741 -0700 committer Zach Kelling 1786666741 -0700 build: graph v1.2.37 -> v1.2.38 (a hop fee must be a uint24) Co-authored-by: Hanzo Dev ZxDtree bc0b7515ff09fd9bc0202c7f9d386e7773404114 parent 8993b4773c63698a5812ceec9d2dee31f69d36eb author Zach Kelling 1786666536 -0700 committer Zach Kelling 1786666536 -0700 build: graph v1.2.36 -> v1.2.37 (an amount must fit the word it is rendered into) Co-authored-by: Hanzo Dev 9bxAtree f3535cabd28b411b88c72e6126ac12769c5ad154 parent 41e5e20e5fa9220986058e39e8610569297ddcca author Zach Kelling 1786666056 -0700 committer Zach Kelling 1786666056 -0700 build: graph v1.2.35 -> v1.2.36 (native input read from the hop that names it) Co-authored-by: Hanzo Dev )`TxLtree 762f34775e74dfaeaf58a937a1256d44e4cd7592 parent e22f8ece93ca5d61be32cb5be36981fdcd19a9c7 author Zach Kelling 1786665763 -0700 committer Zach Kelling 1786665763 -0700 Answer the swap form on the paths it actually calls The swap form calls /v1/quote and /v1/swappable_tokens, not /v1/graph/{chain}/{subgraph}/quote. Only the prefixed form existed here, so a TypeScript service stayed in front of this one to serve the unprefixed paths, and the two answered the same questions from two copies of the book. A swap request already says which chain it is for — a quote names the chain of each token, an approval names its chain, a swap carries the quote it came from. So the chain comes out of the request rather than the path, and the request is handed to the mux that chain's subgraph already registered. The handler values are the ones the prefixed routes use; nothing is built twice. Swap and approval need this chain's router. Without one configured there is no address to address a transaction to, so those two routes are absent rather than serving calldata signed against nothing. The subgraph that backs a chain's swap routes is the one holding an AMM book. Picking whichever subgraph started first would have been a race, and a CLOB schema has no pools to price against. Co-authored-by: Hanzo Dev #v3x<tree 7411de3407eb7fe0a075e9b24350b58a636b65c8 parent 4a38efb2675c18cbf6b6bc3a99092ed0aa808d4a author Zach Kelling 1786663650 -0700 committer Zach Kelling 1786663650 -0700 Answer the swap form from the same book the explorer already indexes Two questions a swap form asks that GraphQL does not answer in a shape a form can use: what can I trade here, and what do I get for this. Both read the store each subgraph already fills, so they mount beside its /graphql rather than behind a second service keeping a second copy of the book. quoter_v2 is per chain because the periphery quoter is deployed per chain. With it set the chain prices a V3 route directly; without it the quote falls back to the closed form, which is exact for V2 and an estimate for V3. Co-authored-by: Hanzo Dev DxBtree 995f9bfc687c590a554346a5549d52494f45388d parent 9101f05419436abba4dc0957612f8b311d4f2865 author Zach Kelling 1786659209 -0700 committer Zach Kelling 1786659209 -0700 Take the graph that reads a token's supply, and one sqlite C Market cap and fully diluted value printed a dash on every token page. The supply behind both was never read for a token already indexed: a real symbol was taken as proof the row was finished. graph v1.2.31 asks what is actually missing, keeps every field it already had, and reports a supply in whole tokens whatever the source. Asking is what a start does now, so the flag that used to gate it is gone. The same pin brings the sqlite the whole process opens under one name. csqlite is the house amalgamation, registered "sqlite3"; upstream mattn compiled a second copy of that same C and the link failed on darwin, while the hanzoai/sqlite wrapper takes "sqlite" — already modernc's, which arrives with hanzoai/replicate — and panics in init. One C, three packages, no argument. Co-authored-by: Hanzo Dev u%x[tree 35ab219995e214ed477d378bcb04f0bbf22196e5 parent 396fd6773c6fc4a597bb11b6d8173eaa36ad62d7 author Zach Kelling 1786628887 -0700 committer Zach Kelling 1786628887 -0700 Carry each chain's mint and treasury to the indexer Supply cannot be read from a node — the genesis alloc is not exposed and summing every account is not a query — so the mint is declared per chain beside the factory addresses. The treasury address is declared too, and its balance read live, because that is the number that falls as tokens reach holders. Co-authored-by: Hanzo Dev ˬx$tree 3f9a9f6aa1d8648d7b868165692bfac05a6d9f0d parent f4d904d86e4266073315ad20b687df649f2f7308 author Zach Kelling 1786595290 -0700 committer Zach Kelling 1786595290 -0700 Take the graph that reads native supply and stake Co-authored-by: Hanzo Dev Z>x/tree d9b9f25ccfe63fea17983f098007e9671945f639 parent 939827e096c8f6ff084c38fcea679e9a4e9a60aa author Zach Kelling 1786494759 -0700 committer Zach Kelling 1786494759 -0700 Take the graph that prices trades without the JSON extension Co-authored-by: Hanzo Dev L^ܔxktree 08b1d4298e37fce853b2bfcc7f3ad7026eadceb4 parent bdd6f665dfdcab4b295b176ce379872575ef334d author Zach Kelling 1786494348 -0700 committer Zach Kelling 1786494348 -0700 Take the graph that reports its swap writes The valuation line now says how many trades it priced, so a write that changes no rows is visible instead of silent. Co-authored-by: Hanzo Dev 0Rxtree a75ab7c5fcc2af1757c3da844a26f8341759d9fb parent 94a136ca7dd5d245bed03393b6316ee4ffa38ee0 author Zach Kelling 1786492635 -0700 committer Zach Kelling 1786492635 -0700 Take the graph that values its swaps Pool pages showed volume over trades that each reported nothing. The indexer computed each trade's worth and dropped it; it now writes it, batched, so a swap list adds up to the total printed above it. Co-authored-by: Hanzo Dev ͟Dx3tree d71db386f317889e08e0f58aeaac84efe4561611 parent 4f9994fa4a5be4d5858eea1dd37d2cd297c7f8cb author Zach Kelling 1786478037 -0700 committer Zach Kelling 1786478037 -0700 graph v1.2.20 — an unparseable query is refused, not held open Co-authored-by: Hanzo Dev \`/xtree 9dcd94d05073d56413f7740838b9c4231cb4633f parent 9482004bbc71da42a54f3048a04908dbcd497257 author Zach Kelling 1786477718 -0700 committer Zach Kelling 1786477718 -0700 indexer v1.5.4 — an index follows the chain it was pointed at Zoo relaunched and its index stayed on the chain that was replaced, serving 24,607 blocks of it while the live chain sat at 9,564. The block indexer resumed from a cursor left above the new head, so it had no way back on its own. v1.5.4 reads block 0's hash to tell a rebuilt chain from a slow node, and starts over only for the former. Every chain in chains.yaml is indexed by this binary, so each of them was exposed to it; zoo is the one it happened to. Co-authored-by: Hanzo Dev ("x"tree 245f5e9860654ec4c8dc1f842c22ea3f8b1c6cd5 parent 82f46085bd46e8e8c022662c1f85fe9bbac847fd author Zach Kelling 1786476057 -0700 committer Zach Kelling 1786476057 -0700 graph v1.2.19 — every field a document asks for, and a row's token is the token parseTopFields split top-level fields on newlines, so a minified document was answered with its first field alone and no error. The explore page asks for its bundle, factory, tokens, pools and day series in one document. Co-authored-by: Hanzo Dev yx2tree 767a840b49116c7c008f6def74fe36432ed5f29e parent b61d5fe7b7e6dc2d03a1ccf8e9f7512780251418 author Zach Kelling 1786472765 -0700 committer Zach Kelling 1786472765 -0700 graph v1.2.18 — a day nobody observed reports no value locked Co-authored-by: Hanzo Dev P_]-x&tree 2ad6fc21531b099a3bbaeb8f6ca81e75fe5dd023 parent 63ad47a6f47d4eaa2898a38cc4b11b57e8cef075 author Zach Kelling 1786472489 -0700 committer Zach Kelling 1786472489 -0700 graph v1.2.17 — token, pool and protocol day series Every price chart read "Missing chart data": tokenDayDatas, poolDayDatas and uniswapDayDatas each answered [] from a stub, and the client draws nothing under three points. They now carry a day per subject rolled out of the trades already indexed, so the history appears at once rather than starting today. Swap timestamps become the block's time — they held the block number, which is also why no day could be computed from them. Co-authored-by: Hanzo Dev V!xtree a96be3d245ad18f4d3d3ae035e0017fe6776fd76 parent 93b0e4c5bdb905b2be8b9b7ba7693bed7ed1c1aa author Zach Kelling 1786471918 -0700 committer Zach Kelling 1786471918 -0700 graph v1.2.16 — a chain's factories come only from its config Removes the indexer's Lux-mainnet fallback for FactoryV2/FactoryV3/ Native, which every chain but Lux was silently inheriting, and adds ZUSD to the stable anchors so Zoo's book prices in dollars instead of reporting 0.00. Co-authored-by: Hanzo Dev L 5x[tree 32072fbc68275e78803ef3f9459eca53e27f2096 parent e57e8315707e02c374172e5942b421d783a11496 author Zach Kelling 1786471071 -0700 committer Zach Kelling 1786471071 -0700 each chain declares its own AMM factories and native token One process indexes six chains. FactoryV2, FactoryV3 and Native never reached the graph indexer from a chain's config, so every chain but Lux fell through to the indexer's Lux-mainnet defaults: the zoo subgraph matched PoolCreated against Lux's factory, registered no Zoo pool, and priced what it did see in WLUX. zoo.exchange read that endpoint. These are identities of the chain being indexed, so they travel with the chain: three fields on ChainConfig, passed straight through. A chain that declares none now indexes no AMM, which is the honest answer. Co-authored-by: Hanzo Dev ə"d x tree c0acc66b56f35a0c2a41d2252f8ac5e74e2e651f parent ae873d5974d04fe2f754d4cfa475010cca944d14 author Zach Kelling 1786420465 -0700 committer Zach Kelling 1786420465 -0700 graph v1.2.15 — tokens carry a price again v1.2.15 publishes what the valuation pass had always computed: bundle ethPriceUSD and per-token derivedETH. Without them every market on lux.exchange and the explorer showed real TVL and volume beside a blank price and no market cap. Co-authored-by: Hanzo Dev cbx(tree ea0b8f9d512495b2cf345de17767be9b3a9a5f64 parent 16a96ed0a3e3e1df638e7a6da05eed18ff7d1276 author Zach Kelling 1786202345 -0700 committer Zach Kelling 1786202345 -0700 stats: measure the span between the first and last block, not the oldest and newest timestamp 1.5.12 stopped a block with no time from anchoring the span at 1970, which fixed Hanzo — 58,370 seconds per block became 10.3, its real cadence. It did nothing for Zoo, which still read 2,387 for a chain building one every twelve: Zoo's stray row is not timeless, it carries a plausible timestamp dated 1.76 years before Zoo's own first block, and no filter on the VALUE can tell that from a legitimately old chain. Nothing about the value distinguishes them. The ORDER does. Timestamps are monotonic in block order by consensus rule, so the chain's elapsed time is the last block's time minus the first block's — by number. On a sound index that is identical to MIN and MAX of the column; on a damaged one it is the answer and MIN/MAX is not. Zoo's first block is three days old, so three days is what its span should have been all along. This subsumes 1.5.12: a stray row only moves the answer now if it is an endpoint, and a timeless one is still skipped because a block that does not say when it happened cannot bound how far apart blocks are. The suite covers both shapes at once, numbered mid-run the way a damaged row actually sits: epoch 0, and two years early. The old query reports 1.26e7 seconds per block on the second. Co-authored-by: Hanzo Dev g^Rx'tree 1ebcb39b0ea7175e5e71bea7dbe0186870c8d48b parent 216ef5d8bf16fc56d057615f07af1ecf863ae538 author Zach Kelling 1786201656 -0700 committer Zach Kelling 1786201656 -0700 stats: a block with no time cannot bound the chain's history 1.5.11 made the average block time readable, and it read 58,370 seconds on Hanzo — 30,602 blocks over an apparent 56 years, on a chain that builds one every 11 seconds. Zoo read 2,389 for the same 11-second cadence. Lux read 50.3, which is right, so nothing looked systematically broken. Both have a single row whose timestamp parses to epoch 0. The span is MAX-MIN, so that one row anchors it at 1970 and the other thirty thousand contribute nothing: the answer stops being about the chain and becomes a restatement of the current unix time divided by the block count. 1.786e9 over 30,601 intervals is exactly the number that came out. The span now counts only blocks that carry a time. That is not a threshold to tune — a block with no timestamp holds no information about how far apart blocks are, and including it invents the interval it appears to measure. Reproduced in the suite: five blocks a minute apart plus one row at 1970-01-01 reports 3.57e8 seconds per block on the old query, 60 on this one. Co-authored-by: Hanzo Dev Yxtree 6f9fa527cc14f169eedeb548add22dbe89c925de parent 6156f554f7fa639af584d3b193ab5de3e7a1b486 author Zach Kelling 1786196223 -0700 committer Zach Kelling 1786196223 -0700 explorer: answer every request from the chain its host is served One binary answers explore.lux.network, explore.hanzo.network and explore.zoo.network. Only /envs.js and the slug-prefixed /v1/indexer/{slug} routes knew that. Everything else read whichever chain the config called default, so Hanzo's home page printed 1,107,383 total blocks above its own Latest blocks list topping out at 29,805 — Lux's number, on Hanzo's page, overstating Hanzo's chain 37x and Zoo's 49x. Measured on all three brands. Config.Serves(host) is now the one thing that answers "which chain is this request about", and the three surfaces that were guessing ask it: * StatsService keeps a read handle per chain instead of one pinned at startup, so /v1/counters, /v1/lines, /v1/pages/* and /v1/stats report the host's chain: 1107259 / 29805 / 22728 on the three brand hosts, where all three read 1107259 before. * The realtime stream carries the host's chain. It carried all of them: a 45s read of /v1/base/realtime returned the same 6 cchain + 14 hanzo + 5 zoo events on every brand host, and the SPA appends what it is sent, so a 50-block page rendered 63 rows with 2 Lux on top and 8 Zoo at the bottom. ?chain= still overrides; an empty filter no longer means "all chains", because no brand host wants another brand's blocks. * A slug-less /v1/indexer/* request follows the host, falling back to the default only when the host names no chain (api-explore.lux.network) or names one that is not up. Also here, because they were all the same mistake about the same column: the timestamp in evm_blocks is a Go time.Time bound into a column declared TIMESTAMP, so SQLite stores a datetime STRING, and everything that read it as a unix epoch got nothing and said nothing. * /stats' daily charts were empty on all three brands. strftime with the 'unixepoch' modifier returns NULL on a datetime string, the scan failed, and handlePagesMain discarded the error into `daily, _ :=` — a nil slice marshals to `null`, which the page renders as "No data". Now 22 points. * Average block time read 0.0s on a chain producing a block every 10s: the three-value Scan failed and its error was never checked, so the zero went out as the answer. Now 60.0 on a one-block-per-minute fixture. * /v1/blocks reported `"timestamp": 2026` for every block — CAST of a datetime string takes its leading digits, and 2026 looks like a number rather than a failure. Now a real epoch. * Transactions (24h) was the lifetime total. SQLite orders every INTEGER below every TEXT, so `timestamp > ` was true for all 1.1M rows. blockEpoch and blockDay are the only two spellings allowed to touch that column now. The fixtures were the reason none of this failed a test: they declared the column TIMESTAMP and then inserted integers into it, so the suite exercised a database the indexer never writes. They bind a time.Time now, and on the old queries they fail with exactly what production showed — average_block_time "0.0", empty charts, timestamp 2026. Deleted: the eight per-channel SSE routes at bare /blocks, /transactions, /tokens, /gas-tracker, /stats, /validators, /token-transfers and /internal-txs. Every one of those is also an SPA page path, and one mux cannot serve both; the SPA opens only the multiplexed stream, so they had no subscriber to lose. With them goes the second envelope, the per-channel framing built on every broadcast, and the client's channel field — SSE has one endpoint and one shape. indexer v1.5.3 for the block transaction-count name. Co-authored-by: Hanzo Dev &txOtree be138ec714a7e84c1b8dd2b75db50d68b36c35ef parent 8558c7d562bc6ffeeed2c9b1e745299b0e5cb827 author Zach Kelling 1786130580 -0700 committer Zach Kelling 1786130580 -0700 release: retry the ghcr.io login instead of losing the release v1.5.8 was tagged and produced no image. The job died at step 2 of 5: ::error::Error response from daemon: Get "https://ghcr.io/v2/": denied: denied The credential is fine. Measured on the forge over 7 days, luxfi ran 365 ghcr logins with the same org secret and 27 failed — 7.4% — across 23 repos and a dozen runners, and the same secret succeeded on either side of every burst, including two hours after one. Three readings were tested and all three are wrong: expired token the same secret succeeded at 16:27 today, hours after failures at 20:53 and 21:18 yesterday sick runner failures spread over 12 runners; the worst has 3 of 7, a clean one has 12 of 12 throttling no correlation with concurrency — 7.4% at one login per minute, 10.9% at two, 0% at four and five So it is an intermittent rejection from ghcr, and the only defect on our side is that nothing retries it. docker/login-action does not, and the job dies before the build, so each occurrence costs a release silently: a tag with no image and no failed push to show for it. 27 of those in a week. Five attempts over 75s, backing off. Exhausting all five is a different failure than the one this covers, and says so rather than pretending. --password-stdin, so the token is never an argument and never lands in a process list or a log — docker/login-action's own behaviour, kept. Same shape belongs in the other 22 luxfi repos that publish this way; this one is the repo with a release waiting on it. Co-authored-by: Hanzo Dev \nx Wtree 63f7d999a5be3552279640e1e39810be933d5796 parent d1ddc08aaed207ba2711228c30a0c21d43dcb8d2 author Zach Kelling 1786129576 -0700 committer Zach Kelling 1786129576 -0700 honour chains[].enabled — it was declared and read nowhere `ChainConfig.Enabled` existed on the struct, was written in every chains.yaml we ship, and was consulted by nothing. Only `Graph.Enabled` and the subgraph flag were ever read (supervisor.go). So `enabled: false` registered the chain, spawned its indexer and polled its RPC exactly like `enabled: true` — a switch that looked like a switch and was wired to nothing. Found by using it. lux-mainnet's config lists spc, which is a sovereign L1 and has never been a chain on that network. Setting `enabled: false` and rolling the config changed nothing: the pod still logged [registry] added chain spc (…/v1/bc/spc/rpc) source=config [spc/amm] [indexer] starting [evm] Failed to get latest block: http status 404 at 1,800 errors an hour, against a chain that was already switched off. Honoured in ChainRegistry.Add, which is the single door — config, env, mDNS and the admin API all arrive there — so this is the whole of what the field means, in one place. A disabled chain is not registered, so it does not index, mounts no routes, and does not reach the SPA's chain list (which reads registry.List()). Enabled is now *bool because absent must not mean off. Every config written while the field was inert says `enabled: true` out of convention; a plain bool would read a future config that simply omits the key as false and make that chain vanish with no error and no log. Nil is no opinion; only an explicit `enabled: false` disables. Tests: registration gated in all three states (true / false / absent), a disabled chain proven not to reach the supervisor or the chain list, and LoadConfig proven to decode into the pointer — a wrong yaml tag would leave it nil and silently re-enable everything it disables. Verified by defeating the check: the false and supervisor cases fail, the absent case still passes. Also: the Dockerfile now runs vet + tests in the builder stage. This repo has exactly one workflow, release.yml, which builds on a v* tag; nothing ran the test files at all. Putting them where cgo and sqlite-dev already exist costs no new job, no new runner dependency, and means a release that fails them never becomes an image. Co-authored-by: Hanzo Dev L`H$xKtree f8ab509bd8ea3b3cc177acd71db331a439a3017e parent 23b0301b4dcf9047d2622165a6a41c0f4c72cd3f author Zach Kelling 1786118517 -0700 committer Zach Kelling 1786118517 -0700 deps: indexer v1.5.2 — checksummed addresses resolve, /tokens matches the SPA contract Picks up the two API fixes. A checksummed address (what every wallet emits) 404'd and rendered a 149M-LUX contract as an empty EOA; /tokens emitted address/holders where the SPA reads address_hash/holders_count, crashing the page on an undefined row key. Co-authored-by: Hanzo Dev Ix`tree f5794b50299704fa6d71b74d107b1e1ec26d3859 parent 393a4454b032c676e457c79c9c0cbd798d83b8fc parent a83aceaadb56b16b5d5c029349684b28149cbd4d author Zach Kelling 1786050548 -0700 committer Zach Kelling 1786050548 -0700 Merge the 2026-08-04 publication snapshot into the working history origin/main was force-pushed on 2026-08-04 to a single squashed commit ("Lux Explorer", BSD-3-Clause), which replaced the repository's history and removed every tag. That snapshot is not buildable-current: its go.mod pins luxfi/graph v1.2.0 against the working tree's v1.2.13, and it dropped stats.go, realtime_sse.go and the whole test suite. Building main as it stood would have shipped a binary thirteen graph versions behind, without the dex subgraph fix. Merged with -s ours: the tree is the working source, and the snapshot is kept as a parent so nothing is rewritten and main fast-forwards. The one file the snapshot contributed, static/index.html, is carried over. The one change it made that was clearly deliberate — dropping the agent notes — is kept: LLM.md/CLAUDE.md are now gitignored rather than restored. Co-authored-by: Hanzo Dev 撿Ixatree f5794b50299704fa6d71b74d107b1e1ec26d3859 parent b53f579f6a3519c3a8637620672193c4559c0019 author Zach Kelling 1786050535 -0700 committer Zach Kelling 1786050535 -0700 build: graph v1.2.13, and one CI path that a runner actually serves The dex subgraph answered `{"data":{"markets":null}}` on a 200 while being mounted, subscribed to the 0x9999 DEXFill topic and caught up to the chain head. A GraphQL list field answering null reads as "not deployed / erroring", so a DEX that had simply seen no fills was indistinguishable from a dead pipe. luxfi/graph v1.2.13 makes an empty result an empty list. CI moves to .hanzo/workflows/release.yml on the native git.hanzo.ai runners, matching luxfi/graph. .github/workflows/docker.yml ran on `runs-on: lux-build`, an ARC pool that no longer exists — the clusters have no ARC CRDs and github.com/luxfi reports zero runners at org and repo scope, so every v* tag queued a job nothing could pick up and waited instead of failing. That is why v1.5.4 is a tag with no image. One CI path, one that builds. LLM.md/CLAUDE.md become local-only, per the org convention. Co-authored-by: Hanzo Dev k;xltree 4a3520bf2f2184bb8c1c19162cfdba7471d8af38 author Zach Kelling 1785898959 -0700 committer Zach Kelling 1785898959 -0700 Lux Explorer A single-binary indexer and GraphQL query layer for the Lux network. Copyright (c) 2024-2026 Lux Industries Inc. Licensed under BSD-3-Clause. See LICENSE. Co-authored-by: Hanzo Dev s9gxutree c0237da8e6d98447599decf8e4a6eb4110b82d70 parent 7d827e2b85a67b897679560e2a794ce1b240e481 author Zach Kelling 1785893245 -0700 committer Zach Kelling 1785893245 -0700 fix(explorer): never hand the browser the address the server dials envs.js was emitting ChainConfig.RPC verbatim, so every browser loading explore.lux.network was told the default chain lives at http://luxd-headless.lux-mainnet.svc.cluster.local:9630/v1/bc/C/rpc which no browser can resolve. One field was serving two consumers with opposite requirements: the indexer must dial the service-mesh name, the SPA must get a public URL. Split them — RPC stays the dial address, public_rpc is what the SPA is told, and browserRPC() falls back to RPC only when it is actually reachable from outside the cluster. Emitting "" beats emitting a URL that always fails: the SPA can hide the control instead of offering one that silently errors. Also adds the canonical /v1/stats and /v1/blocks. Everything under /v1, nothing under /api — TestStatsRoutesAreV1Only pins that /api/v2 is not mounted and never becomes so by accident. /v1/blocks CASTs timestamp to INTEGER because the real schema declares it TIMESTAMP and go-sqlite3 turns declared TIMESTAMP columns into time.Time, which will not Scan into int64 — without the cast every row is skipped and a fully populated index answers an empty list. That failure was invisible because the handler swallowed the error; it now logs and reports it, and the bound test asserts rows came back rather than just `<= 200`, which passes trivially on an empty result. Co-authored-by: Hanzo Dev ~1>x`tree fee14ddf78e751d7eab3becb2baf2c195b7c51f7 parent ef9cc4e8690a7473933a267039fed5e2007e2fe1 author Zach Kelling 1785816119 -0700 committer Zach Kelling 1785816119 -0700 rpc: /ext/ -> /v1/ on our own hosts luxd serves /v1/*; /ext/* 404s. Third-party chains keep their own paths. Co-authored-by: Hanzo Dev mCCx5tree 142dac8fab28a85b41b56a56c87bf026406c4929 parent f12932e2c19eab9b2aeeb00e4d4ec9cab7520670 author Zach Kelling 1785631175 -0700 committer Zach Kelling 1785631175 -0700 ci: the PAT step falls back to the one credential luxfi provisions The ghcr login was fixed, and the very next step still failed: Resolve cross-repo PAT for private luxfi/* deps -> failure Build & push (amd64) -> skipped because it reads GH_TOKEN then UNIVERSE_PAT, and orgs/luxfi provisions neither. Measured: repos/luxfi/ has no secrets at all, and orgs/luxfi holds exactly GHCR_USER + GHCR_TOKEN. Both names therefore evaluate to "" and the step exits 1. GHCR_TOKEN is a real GitHub PAT -- it has to be, because ghcr.io accepts nothing else -- so it can resolve private modules as well as pull images. Added as a third rung that REPORTS which secret it used (`Using secret: $src`), rather than a `||` chain that swaps credentials silently. Same fix already proven green in luxfi/trader. Co-authored-by: Hanzo Dev v`Q'xstree 95c5acb58a8686d144f72a5e4564dea6ea3943da parent 7571f94150c91a08f0e08a7f483e10f10f876bb0 author Zach Kelling 1785283342 -0700 committer Zach Kelling 1785283342 -0700 build: drop the luxfi exceptions — graph and indexer are public now The list named github.com/luxfi/graph and github.com/luxfi/indexer because they were private and 404 on proxy.golang.org. Both are open source now and both serve from the proxy, so the exceptions have nothing left to do — and every name on a GOPRIVATE list is a module Go fetches from git and trusts unverified. Co-authored-by: Hanzo Dev XNNxtree 09cf9ad018c416d9a2093e6070a7b17730959094 parent 849178ea59566a2d9e35f59afd96e0899990d29d author Zach Kelling 1785279925 -0700 committer Zach Kelling 1785279925 -0700 build: mark lux-private private, not all of luxfi GOPRIVATE switches off the module proxy AND checksum verification together. Covering github.com/luxfi/* meant every luxfi module was fetched straight from git and trusted without verification — which is how moved tags got captured into module caches and served from them indefinitely, making the same commit build on one machine and fail on another. Nearly all of luxfi is public and on proxy.golang.org, so it belongs under normal verification. The private org is lux-private. Twelve luxfi repos are still private AND still 404 on the proxy, so they are listed individually rather than by wildcard — coverage now matches what actually needs a direct fetch, and every other luxfi module is verified against sum.golang.org again: bridge broker compliance erc20-go fasthttp graph hsm indexer mpc ordering password pool The right end state is those repos moving to lux-private; until then the explicit list keeps the exemption honest instead of blanket. Co-authored-by: Hanzo Dev !ɖExVtree 33ac9f91c5965bbde3e680ec613c8120be51ace5 parent e5bf01aceae8ecea2215a1ef9d195a67f5d7d6de author Zach Kelling 1785256681 -0700 committer Zach Kelling 1785256682 -0700 deps: drop go.sum lines that disagree with the checksum log These hashes were recorded from direct VCS fetches made while GOPRIVATE covered github.com/luxfi/*, which switches off the module proxy and checksum verification together. Tags moved afterwards, so what is written down here no longer matches what sum.golang.org holds and the build refuses to verify. proxy.golang.org still serves the originally-published bytes and those verify against the log, so dropping only the disagreeing lines and re-tidying restores a verified module graph with no version change. Lines that agree are untouched; this is not a regenerated go.sum. The failure followed the machine rather than the repository — the same commit built wherever the module cache was clean. Any machine or CI runner that fetched luxfi modules under the old GOPRIVATE holds the same poisoned entries. Co-authored-by: Hanzo Dev WÑ7xqtree 14b373a04559a40ea55b0d50c866cf06b5879435 parent 8d136c68437a27bb4a23876557760aaad05ff1aa author Zach Kelling 1785201744 -0700 committer Zach Kelling 1785201744 -0700 docs: publish /v1/bc/C/rpc, drop dead /ext/ URLs /ext/ is gone from api.lux.network, api.zoo.network and api.hanzo.network (all 404 today), so every published /ext/ URL was already broken. Convert to the one canonical path and fix the URL forms that were dead for other reasons at the same time: /mainnet|/testnet|/devnet path prefix -> the per-network host (404 today) api.testnet.lux.network, testnet-api.lux.network -> api.lux-test.network /ext/C/rpc (missing bc/) -> /v1/bc/C/rpc chain aliases + blockchain IDs under api.lux.network -> the L1s own host Third-party RPC hosts (Avalanche, Flare, blastapi) are left untouched. Co-authored-by: Hanzo Dev cU#7xqtree f913f61dbdc0c8e93b0ee61f278fb557eb2d7e92 parent 066916145d3f3b0b2d36ba13d21bc83b751e1356 author Zach Kelling 1785200443 -0700 committer Zach Kelling 1785200443 -0700 docs: publish /v1/bc/C/rpc, drop dead /ext/ URLs /ext/ is gone from api.lux.network, api.zoo.network and api.hanzo.network (all 404 today), so every published /ext/ URL was already broken. Convert to the one canonical path and fix the URL forms that were dead for other reasons at the same time: /mainnet|/testnet|/devnet path prefix -> the per-network host (404 today) api.testnet.lux.network, testnet-api.lux.network -> api.lux-test.network /ext/C/rpc (missing bc/) -> /v1/bc/C/rpc chain aliases + blockchain IDs under api.lux.network -> the L1s own host Third-party RPC hosts (Avalanche, Flare, blastapi) are left untouched. Co-authored-by: Hanzo Dev ]#Vxktree 970fa6b9ab947d81ff81bc48a384a2ff4e378e8a parent 34a292b8e831269095ef7697c6783832dba4ce81 author Zach Kelling 1785187721 -0700 committer Zach Kelling 1785187721 -0700 fix(explorer): balances from the chain; one source for sibling hostnames indexer v1.4.6 -> v1.4.7 and pass the chain's RPC to the standalone API, so native-coin balances are read from the node rather than from evm_addresses.balance — a column the indexer writes as the literal '0' on first sight and never updates. Every address page reported a balance of zero, WLUX's 159,126,795.518 LUX included. v1.4.7 also counts token holders and transfers from the rows that hold them, stops calling the base fee "burnt" on a chain that credits the whole fee to the coinbase, and returns addresses on the evm_* schema instead of an empty page. The network switcher advertised testnet.explore.lux.network and devnet.explore.lux.network. Neither resolves; the live hosts are explorer.lux-{test,dev}.network. networksForHost already derives sibling hostnames from the request host and derives them correctly, so the switcher now takes its domains from there and config keeps only what config knows — the label and the chain ID. Devnet's was wrong too: 96370, where the devnet genesis cChainGenesis.config.chainId and a live eth_chainId both say 96367. Co-authored-by: Hanzo Dev 2߼#x1tree 6dd88058fa97af2a06f1465fadb65cd28dcc2d7a parent a67f2a66441b6fed82d91ed40ccf2e06b3ed41d4 author Zach Kelling 1785116567 -0700 committer Zach Kelling 1785116567 -0700 build: bump luxfi/graph v1.2.11 -> v1.2.12 (bounded swap window in the valuation pass) v1.2.11 stopped the pass writing a row per swap; v1.2.12 stops it reading the whole table too. The C-Chain's AMM swap history spans a million blocks in a 732 MB store, so an unbounded rescan every 30s grows with chain age forever. Co-authored-by: Hanzo Dev 6!3x>tree a16762c6b41ddeb7e0037ed9ec739de803104074 parent 6837310ff00014607222bbc9d8d2872151301e92 author Zach Kelling 1785116333 -0700 committer Zach Kelling 1785116333 -0700 build: graph v1.2.11 + label every graph indexer with its chain/subgraph v1.5.1 in the cluster showed one chain's valuation pass reporting and two others silent — and the log gave no way to tell which chain any line belonged to, because the graph indexer was the one component here that did not prefix its output. Config.Label (new in graph v1.2.11) fixes that: pass the same "slug/name" this supervisor already uses everywhere else. v1.2.11 also stops the valuation pass writing a row per swap (which is what wedged the busy chains) and reads V3 swap amounts as the int256 they are. Co-authored-by: Hanzo Dev (xwtree c919555fb13b0127a8b76829bfe6e7cd359a161a parent 4f1395b269e9dcbf72db1ebc7b047416c4703d82 author Zach Kelling 1785115303 -0700 committer Zach Kelling 1785115303 -0700 build: bump luxfi/graph v1.2.9 -> v1.2.10 (AMM valuation pass) v1.2.10 adds the valuation pass that derives the AMM graph's USD aggregates from on-chain balances. Without it the explorer's /v1/graph//amm/graphql served pools and tokens whose totalValueLockedUSD, volumeUSD and token0Price were empty strings — which is what left every TVL / 24h-volume / active-pool figure on the exchange blank. Co-authored-by: Hanzo Dev SxTtree 6e68d573736a189bda7a7a8e3580025331e91321 parent 0b4ebbd9be32e30eddc41c3ae4627e6ba6ba691c parent 48f3ebc0ab477a75e81e88debfc3c69393ef1183 author Zach Kelling 1785115257 -0700 committer Zach Kelling 1785115257 -0700 merge: P-Chain indexing + /v1-only luxd RPC + chain stats Integrates feat/pchain-indexing into main so nothing is left behind a branch. Co-authored-by: Hanzo Dev 2xdtree 6e68d573736a189bda7a7a8e3580025331e91321 parent 69a42bc965473a2bcf3622c45ffede52fe1cadda author Zach Kelling 1785085998 -0700 committer Zach Kelling 1785085998 -0700 chore: sync working tree Commits 3 outstanding change(s) that were sitting uncommitted. No build artifacts and no secrets in the changeset (both checked). rQ3x5tree 488fb433c77f90c51c0dc3bcf38e7aef6af1b04d parent 7b2a74df9616b75cd13f3c8f361874e33bc84d7e author Zach Kelling 1783519936 -0700 committer Zach Kelling 1783519936 -0700 feat(supervisor): run P-Chain (platform) indexing for linear/platform chains runChain handles cfg.Type "linear"/"platform": build the platform adapter, create pchain_blocks via the generic chain indexer's Init (which also runs the adapter's validator/delegator schema), then poll — fetch+parse+store recent blocks and SyncValidators each interval. Blocks are written via store.StoreBlock (not the chain indexer's broadcasting StoreBlock, whose subscriber channel nothing drains here). mountIndexerAPI gates readiness on pchain_blocks for platform chains (evm_blocks for EVM). Co-authored-by: Hanzo Dev _1xtree db1395299513310245d3e8ae6b535a8be4fac5db parent 0b4ebbd9be32e30eddc41c3ae4627e6ba6ba691c author Zach Kelling 1783117244 -0700 committer Zach Kelling 1783117691 -0700 fix: direct-luxd /ext/bc/ -> /v1/bc/ (luxd is /v1-only) luxd v1.34.x serves chain RPC at /v1/bc/*; /ext/bc/* 404s. mdns.go discovers luxd nodes directly (base = http://: from mDNS) and constructs their per-chain RPC + platform.getBlockchains routes — these are direct-luxd calls, so they move to /v1/bc/. registry_test.go fixtures use localhost:9650 direct-luxd URLs, flipped to match. Public-gateway URLs (api.lux.network in chains.example.yaml / README.md) are left as /ext — the public gateway still accepts /ext externally. Co-authored-by: Hanzo Dev Z;&xktree c2ffd92c2b891e1f42156239d12d81a663e3ebaf parent a47755267bc9f925bd3d29bd558eaef9f80fc171 author Zach Kelling 1782709973 -0700 committer Zach Kelling 1782709973 -0700 build: bump luxfi/graph v1.2.6 -> v1.2.9 (bound BASE/QUOTE pair symbol + assetsBound on 0x9999 markets) graph v1.2.9 enriches the 0x9999 DEX Market with a human pair symbol + assetsBound so the exchange-api real-asset gate admits native markets (was stripping all of them on the poolId-hex symbol). Pulls luxfi/database v1.19.3 transitively. go.sum regenerated for luxfi modules (upstream re-tag staleness on age/pq). tʛxtree 11a675df98ad833acdfe29b57841509bb7c710b0 parent 271b9eb27bb5433b401df192bb8e4c9bc9212134 author Zach Kelling 1782704255 -0700 committer Zach Kelling 1782704255 -0700 docs(brand): add hero bannerCxtree ba1168c76ff9d9bc20b191b67a93963d325cd65d parent 2e9694909601aaf634c8a30f2ac4316676f8a15a author Zach Kelling 1782704254 -0700 committer Zach Kelling 1782704254 -0700 chore(brand): dynamic hero banner!Eԗxtree c36862c023beba7ac4c0610ed01bd5777b78061c parent 345290e6df11a6dfb5477892914f9fd7e6d7c0d1 author Zach Kelling 1782426262 -0700 committer GitHub 1782426262 -0700 chore: bump luxfi/database v1.19.3 (#13) Co-authored-by: zeekay 4Tx tree ca35b980476918978416e94a9ad803e4f24cacef parent 3611483f2bbb74121a458560d25c43aa848d616e author zooqueen 1782251940 -0700 committer zooqueen 1782251940 -0700 build: bump luxfi/indexer v1.4.5 → v1.4.6 (real tx fee + block burnt_fees/rewards, decimal value) nX1xIN1E}ZҞ6@e:pD )kv_U}Bdήn!Ōn CC\Lg,ȤV adFࢭدf57J3?ao\'N_G~L|cBìyryBk/d{ #:/k؅2:^P!Ŝjv"xc\*\{570Bw`^R{+{6/n_ie#x5tree 3c3dec99c575de736fb145dd30c3c94f48ce3d12 parent 066a8060c6b97b6e0229c089d2cad374bbe9871b author Zach Kelling 1782111300 -0700 committer Zach Kelling 1782111300 -0700 feat: enrich AMM token metadata — bump graph v1.2.3→v1.2.6 + opt-in backfill graph v1.2.6 reads ERC20 symbol/name/decimals for AMM Token entities (was address-placeholder). supervisor.go runs graph's BackfillTokens at startup when BACKFILL_TOKENS=1 to enrich existing placeholder rows in place (≤3 eth_calls/token, no re-sync), before the live indexer loop. n̜Ixctree ba716416600507c457856837e97bedd31333863f parent b0ad7f49e7c86b7ab0e9bdd6cb398cd2c18786b8 author Zach Kelling 1782079627 -0700 committer Zach Kelling 1782079627 -0700 fix(docker): resolve private luxfi modules + GHCR push via cross-org PAT The v1.3.1 image build reached the runner (lux-build works) but failed two ways that the local build now proves fixed: 1. Dockerfile cloned private luxfi/{indexer,graph} over unauthenticated https -> 'could not read Username'. Those clones were vestigial: explorer has no replace directive, so under -mod=mod graph v1.2.3 + indexer v1.4.5 resolve from the module cache, not siblings. Drop the clones; add the node-style BuildKit-secret git auth (ghtok) + GOPRIVATE/GONOSUMDB/GONOPROXY before go mod download so private modules resolve. 2. GHCR push would be denied (repo-scoped GITHUB_TOKEN). Log in with the cross-org PAT (GH_TOKEN/UNIVERSE_PAT) and stamp org.opencontainers.image.source so the package stays linked. Verified locally: docker buildx build --secret id=ghtok,... compiles the unified FE+indexer+graph binary green (go mod download 74s, go build 98s, image exported). o(xztree 61f61a06c21ead11e8dbede2e71c095d7d9df936 parent c93423f735b1f30ed3428bb37c7de0f2e5949fe8 author Zach Kelling 1782079120 -0700 committer Zach Kelling 1782079120 -0700 ci: route docker.yml off classic [self-hosted,linux,amd64] to lux-build ARC The classic-triple pool is serviced by fleet arcd hosts (dbc/evo/spark) that are not reliably available — the v1.3.0 tag never produced an image and recent builds sit queued. lux-build is the org-scoped autoscalingrunnerset in lux-k8s (listener healthy 18d, scales 0->N on demand) that already publishes the node image. Same one-line pool swap node/docker.yml uses. d yPxtree 5ddb06aa57620e76513b326d53f1bb9d0be21b91 parent 5a664afa2140a96622500c9faa59b3a33804dd0b author Zach Kelling 1782078763 -0700 committer Zach Kelling 1782078763 -0700 deps: bump graph v1.2.2->v1.2.3 (native 0x9999 V4/DEXFill indexing, dex+amm subgraphs) + pin indexer to real v1.4.5 tag graph v1.2.3 lands the native 0x9999 DEX indexing fix: dex/amm builtin subgraphs, 0x9999-scoped Fill source (DEXFill log), keccak topic-hash fixes, and re-genesis self-heal. The supervisor already wires PoolManager(0x9999)+StartBlock into graphidx.NewWithConfig and mounts the dex+amm subgraphs at /v1/graph/{slug}/{subgraph}/graphql; this bump makes the engine those routes resolve against carry the fix. Also replaces the unpushable phantom pin indexer v1.4.5-0.20260526184203-3b72d71cc8fd (revision 3b72d71cc8fd never existed on origin) with the real published indexer v1.4.5 tag (main HEAD ac537780: server-side per-(token,holder) balances + log/transfer column aliases). This unblocks the unified explorer Docker build, which resolves graph+indexer from go.mod under -mod=mod. Verified: go mod tidy clean; CGO build of the unified binary green; go test ./... ok; graph dex_route_test confirms markets/fills resolve on the dex schema from 0x9999 entities. S = xtree f4b03ec624fdd7dea2f4332c3caa20b447df8f63 parent d702e5b05e858ac3723f5ddbe352d3a9fd572f57 author Zach Kelling 1782069971 -0700 committer Zach Kelling 1782069971 -0700 feat(explorer): pass PoolManager(0x9999)+StartBlock to graph indexer; mount dex subgraph - config: add ChainConfig.PoolManager (DEX settlement precompile, default 0x9999) - supervisor: runSubgraph uses graphidx.NewWithConfig (PoolManager + StartBlock) - chains.example: cchain mounts dex (CLOB) subgraph + pool_manager x(tree b63098112a92ad45d48589d236f4b40f7a00c7ce parent 2f0af7d7ca190dd3a4a317c6cd85c6d6484fdf4c author zooqueen 1781713604 -0700 committer zooqueen 1781715344 -0700 docs: tidy LLM.md indexes; CLAUDE.md -> LLM.md symlink convention Co-authored-by: Hanzo Dev U[x?tree 2e60baefb8dd27831edfeaa810087340cab9b5bd parent 3959357be3f0d9e0dfc31ed6ad3941d73d727ba9 author Zach Kelling 1781148027 -0700 committer Zach Kelling 1781148027 -0700 ci: route to canonical native arcd labels [self-hosted, linux, ] Replaces non-canonical scale-set / org-prefixed labels with the existing labels every arcd host registers with. Matches evo for amd64 and spark for arm64. No new labels added. ؓ#]x+tree b602356e6af99611f26e0750737df4bfcdfd1524 parent 73749c70f4def7abc8a4b1ed2d948a2d68bc6c20 author Zach Kelling 1781122861 -0700 committer Zach Kelling 1781122861 -0700 feat(v1.3.0): drop embedded SPA — per-brand FE Deployment owns the UI The Go binary is now a data-layer service only. The `/` catch-all that served an embedded SPA shell is gone; v1.3.0 keeps just the endpoints the FE depends on: - /v1/* — indexer + blockscout-compat REST APIs - /health — health probe - /envs.js — runtime brand/chain config (window.ENV) - /icon.svg, /logo.svg — per-host brand SVGs (overlay-friendly) - /icon-{slug}.svg, /logo-{slug}.svg — extra named brand assets Every other path returns 404 so the IngressRoute hands it off to the per-brand Blockscout FE Deployment (ghcr.io/{brand-org}/explore-{env}). Concrete deltas: - frontend.go: drop handleSPA, writeIndex, f.index; replace with handleNamedBrandAsset + brandAssetNames discovery - frontend_test.go: TestFrontendNoSPA + TestFrontendBrandAssetsServed replace the index-html overlay tests - Dockerfile: drop Next.js frontend build stage; runtime image is just the Go binary + brand SVGs (no embedded HTML) - static/index.html: removed (60-byte placeholder) The per-brand FE Deployments + IngressRoute patches that complete this split live in the cluster (lux-mainnet + lux-testnet namespaces). Source of the FE images: luxfi/explore via Dockerfile.branded. %x+tree e6019e0f297add27651850bbf8f58cd6b264ec99 parent 366e4c57d2a864b34e029e3b677f386bf677dd32 author Zach Kelling 1781119044 -0700 committer Zach Kelling 1781119044 -0700 chore: scrub default from Dockerfile NETWORK_CURRENCY_SYMBOL Replace the default currency symbol + network ID (8675312) defaults with Lux mainnet defaults (LUX, 96369). The explorer binary white-labels per-tenant via runtime env, not via -specific build defaults. le-x"tree 770866e35ba51fd79adb60ad5b776a88fe3b2843 parent c75790d446cffe079b8d44e4be04095412967546 author Zach Kelling 1781115662 -0700 committer Zach Kelling 1781115662 -0700 fix(spa): brand merging + env-tag canonicalisation - BRAND is now a merge of SERVER_BRAND (chains.yaml-supplied) and INFERRED_BRAND (host parser table). Server wins on name/coin/accent when it's non-default; inferred fills in iconUrl/logoUrl when the chain config doesn't carry per-brand SVG paths. Stops Zoo rendering with the default Lux favicon when chains.yaml omits icon_url. - networkFromHost now canonicalises "test"→"testnet", "dev"→"devnet" so the dropdown label matches the server-side VITE_CURRENT_NETWORK. P8xrtree 313b53ff42c8059407686565713613fb264a7933 parent 248e16dcb43b82f6522892a790b15ca4d8a3f180 author Zach Kelling 1781114859 -0700 committer Zach Kelling 1781114859 -0700 fix(spa): client-side network derivation fallback for older images The Go-side networksForHost was added in v1.2.20 but the deployed image is still v1.2.18 (CI pool gap — lux-build AutoscalingRunnerSet is missing from arc-system). The SPA now also parses location.host client-side so the network switcher works when /envs.js doesn't ship VITE_CURRENT_NETWORK / VITE_NETWORK_HOSTS. Same shape rules as the Go side: explore.{brand}.{tld} (mainnet, preserve tld), explorer.{brand}-test.network (testnet, .network is canonical). Numeric and *.local hosts skip the dropdown. This lets us ship the cross-network switcher via an EXPLORER_STATIC_DIR overlay (ConfigMap-mounted SPA) without rebuilding the image. 2r^xtree d939c2cfff5d773b3fa266566cd0aad949955863 parent 2cbbb4f33345fb35f4156ba59990aa7a445c6d1f author Zach Kelling 1781114715 -0700 committer Zach Kelling 1781114715 -0700 feat(frontend): cross-network switcher (mainnet ↔ testnet) in SPA handleEnvs now returns VITE_CURRENT_NETWORK + VITE_NETWORK_HOSTS so the SPA can render a Network dropdown next to the Chain picker. When the user picks "testnet" from explore.zoo.network the SPA redirects to explorer.zoo-test.network (and vice-versa). Sibling host derivation lives entirely in Go: - parseBrandEnv extracts (brand, env, dotted, ok) from any of our deployed host shapes — explore.{brand}.tld, explorer.{brand}-test.network, explore-{brand}.lux.network, explore-{brand}-test.lux.network. - networksForHost composes the sibling map. Mainnet TLD is preserved when the user is on a brand-owned host (explore.hanzo.ai stays .ai); testnet is always {brand}-test.network because that's the canonical shape. - isValidBrand rejects numeric stems so an IP host (10.0.0.1) doesn't fall through to "explore.10.0.0.1" / "explorer.10-test.network". SPA renders the dropdown above the chain picker; hidden when the host yields fewer than two siblings (local dev, admin tooling). Tests cover all four canonical surfaces (lux+zoo × mainnet+testnet), hanzo's TLD asymmetry (.ai mainnet → .network testnet), the explore-{slug}.lux.network prefix shape, and the unparseable-host guards (IPs, in-cluster service names, localhost). ~ >xtree 3486a514c60f3090f74d24ec1373c50a292d2ec9 parent c3afae17ba2d15c53ff2a3eab0567e5bcdc4fcfa author Zach Kelling 1781113587 -0700 committer Zach Kelling 1781113587 -0700 fix(brand): per-host whitelabel + default-chain — covers *-test.network - host matcher now accepts explorer.* (alias of explore.*) and {prefix}.{slug}-{env}.tld shapes — so explorer.zoo-test.network resolves to the Zoo brand (was falling through to Lux default). - new chainSlugForHost helper drives a default-chain promotion in handleEnvs: when the host pins a chain, the SPA opens on that chain instead of the config-default cchain. explore.zoo.network now defaults to Zoo, not C-Chain. - factored host matching into pure hostMatchesSlug predicate so brand and slug paths share one ground truth. - tests cover both regressions (explorer.zoo-test.network → Zoo, explore.zoo.network → slug=zoo) plus the existing cross-contamination guards (zoofoo must not match zoo). Zvx tree d9a03227883732d65256e94f2a219a14e17ab540 parent 1fcef19f3f59666d3de90dc206a71cdfc9b4a654 author Zach Kelling 1780808721 -0700 committer Zach Kelling 1780808721 -0700 go: 1.26.3 → 1.26.4 (security: crypto/x509, mime, net/textproto) O xtree 12804903a99012bf13bd903ce7f8f0b805b37750 parent c37bb4e8932a06d7abe47a21851ed4e9a46a7b33 author Zach Kelling 1780700385 -0700 committer Zach Kelling 1780700385 -0700 docs: document the unified explorer bundle deployment luxfi/explorer + luxfi/graph + luxfi/explore now ship as ONE Deployment per env on lux-k8s. CLAUDE.md describes the 2-container sidecar layout (explorer Go + explore Next.js), image versions, manifests, and verified public URLs across mainnet / testnet / devnet. $cx4tree 2e336f7b7106557d590bd75931709b232098af54 parent 1e602d24e9d778f956b8fe1e50264e2357707095 author Zach Kelling 1780697122 -0700 committer Zach Kelling 1780697122 -0700 fix(frontend): match per-chain Brand for explore-{slug} / api-explore-{slug} hosts brandStruct only matched bare "{slug}" and "{slug}.tld" host shapes — but the unified explorer ships behind IngressRoutes whose Host() patterns are exclusively `explore-{slug}.lux.network` and `api-explore-{slug}.lux.network` plus brand-owned roots like `explore.hanzo.ai`, `explore.zoo.ngo`, `explore.pars.network`. With the old matcher every per-chain host fell through to BrandDefault ("Lux Explorer"), so per-chain theming silently no-op'd in prod (verified 2026-06-05: explore-hanzo.lux.network /envs.js returned "VITE_BRAND":{"name":"Lux Explorer"} instead of Hanzo). New matcher recognises the four prefix shapes the IngressRoutes produce, both with and without an env suffix (-test / -dev): - explore-{slug}.tld... UI host on lux.network - api-explore-{slug}.tld... API host on lux.network - explore-{slug}-{env}.tld... UI host for testnet / devnet variants - api-explore-{slug}-{env}... API host for testnet / devnet variants - explore.{slug}.tld... UI on brand-owned domain - api-explore.{slug}.tld... API on brand-owned domain Plus the prior bare-{slug} and {slug}-prefix shapes for backward compat. Test coverage: TestBrandStructHostMatching, 18 cases incl. the explore-spcfoo cross-contamination guard ensuring partial-slug- suffix matches don't bleed. #BtxJtree 875012abc092d9024cb6f927a86eb2d713a35dc3 parent ebfcc0dc162ab13d1251f3c22d5f7a869c6427e1 author Zach Kelling 1780682753 -0700 committer Zach Kelling 1780682753 -0700 feat(frontend): runtime static-dir overlay + substantive SPA shell Two related changes that get the explorer SPA rendering real chain data without waiting for upstream luxfi/explore to ship a Next.js static export. 1. Runtime SPA overlay (config.go, frontend.go) New cfg.StaticDir (also EXPLORER_STATIC_DIR env var). When set, the frontend prefers the on-disk copy of any static asset over the embedded FS — so a ConfigMap-mounted SPA shell replaces the embedded 60-byte placeholder without rebuilding the binary. The embedded FS remains the source of truth at build time and the fallback when no overlay is configured. handleSPA + serveBrandFile both check overlay > embedded. Tests cover overlay-present, overlay-missing-file fallback, no-overlay, and env-var-only configuration. 2. Substantive SPA shell (static/index.html) Replaced the 60-byte stub (
) with a vanilla JS SPA — ~7KB, zero dependencies, no React/Next.js. Reads window.ENV from /envs.js, fetches /v1/indexer/{slug}/{stats,blocks, transactions}, renders KPIs + Latest Blocks + Latest Transactions with per-chain switching and brand color/title overrides. Polls every 15s. Stores selected chain in URL hash + localStorage. This is the explorer's default UI until upstream luxfi/explore ships output: 'export' and the Dockerfile's optional pnpm-build overlay activates. Dockerfile: drop the leftover merge-conflict markers around the SPA build stage, keep the explanatory comment. Tests: 4 new in frontend_test.go covering overlay precedence + env-var fallback. All existing tests (registry, realtime) still pass. j~nx1tree 9aa3177294db194eca31bbb3eff2d631aaa4553b parent 4083aa96e18473c8a7290658af15a891ec69d89d author Zach Kelling 1780423898 -0700 committer Zach Kelling 1780423898 -0700 chore(deps): go get -u ./... Updated dependencies to latest minor versions via go get -u + go mod tidy. eW]jxtree 0314fc2a348c06d928a7e095079b7dc1331cf7dd parent 4e7bb24121304e9e4bdc21d233af4292ab3c3cf9 author zooqueen 1780289380 -0700 committer zooqueen 1780289881 -0700 Add Claude Code project docs (CLAUDE.md, LLM.md) Co-authored-by: Hanzo Dev XTxtree 316a1bf6e906e3527a284b3c1fe0e8fcc9b46b34 parent 422c63af88fe9d6f1f9c5fa64d328306aed697cd author Zach Kelling 1779747200 -0700 committer Zach Kelling 1779747203 -0700 chore: brand-neutral cleanup — remove cross-tenant references \SxMj! b?ݭEJ-h7j9~W_% RIK- ,1Ui3u4 ~?K6)?ԳVxKN0>H]"qT~ Džż}3S"4-e0 qڲAځj(m J I+{'c˞Ѧ{-$'j+SLҥƌ"2\$6.jGW`BȾRHv7X\3mYaremœ-s0 g0by BBΛ90 1@+DyӝlB}1UDBBKEIlfBžĊێlwٱIpgfeSU}l e] YtTFTBeR5Г XR[J}jBeY]1Ԇ>жMn&nxyvI*f%u10E1V9EE66. 3NC3E^Snm:ư,^^5t8&.Ic_]ܢ!?L1,_a~̟770ǍQsE؋F*ŻE'ۮ+R.A%'SM-%(Г%hM'fo}JX9?~>qe);xKߩя߱ O/x tree d7eb53559185f5e2ac8c7313d18df19c97239274 parent 296eee1f72188c6d1e45ba9c327838e45921f287 author Darkhorse7stars <92065535+Darkhorse7stars@users.noreply.github.com> 1779617218 -0700 committer GitHub 1779617218 -0700 ci: drop arm64 QEMU build (2h -> ~5 min) (#11) The previous matrix did linux/amd64,linux/arm64 with arm64 via docker/setup-qemu-action. QEMU-emulated builds of this image (Next.js SPA + Go cgo-sqlite) ran for ~2 hours per tag — fast enough to bottleneck every hotfix tag. Drop arm64. Cluster runners are amd64; Mac devs already run native arm64 under OrbStack with its own arm64 base story. If we ever need an arm64 multi-arch index, the right path is a second matrix entry on a native arm64 runner — not QEMU.e]x)tree bcaf362ae5ffc1c01cb4dac8b65ba4c29f314283 parent ad72ca64976b1d7d6b984c4964746e1a668019ab author Darkhorse7stars <92065535+Darkhorse7stars@users.noreply.github.com> 1779608652 -0700 committer GitHub 1779608652 -0700 indexer: wire chains[].indexer.start_block + default devnet chainId (#10) Two related fixes for running the explorer against a mainnet-fork devnet: 1. Honor the per-chain `indexer.start_block` field from chains.yaml when the indexer DB is fresh. Without this the indexer always backfills from block 0, which on a mainnet fork is 25M+ blocks of irrelevant pre-fork history. Now an operator can set: chains: - slug: evm rpc: http://anvil:8545 indexer: start_block: 25162000 and the indexer skips to that block on first run. Once any rows exist in evm_blocks, start_block is ignored and indexing resumes from MAX(number)+1 as before — backward-compatible for fresh-genesis chains. 2. Default the bundled SPA's NETWORK_ID to 8675312 (the Liquid devnet chain ID). The Dockerfile previously inherited luxfi/explore's default of 8675311 — a stale leftover from before the devnet chainId migration. Adds NETWORK_ID / NETWORK_NAME / CURRENCY_SYMBOL as build-args so the same Dockerfile produces correct images for devnet/testnet/mainnet. Requires luxfi/indexer #8 (StartBlock field on evm.Config) — bumped via `go mod edit` to the post-merge commit d5e65d4b50c1.Ǐ뽜Gx|tree abfe5dc2b9cd0a7a48fa5dd67a21a5394276ab87 parent 08f343c4a1cd227c75962c06833068c0ef8acb6f author Darkhorse7stars <92065535+Darkhorse7stars@users.noreply.github.com> 1779420692 -0700 committer GitHub 1779420692 -0700 fix(sse): minimal HEAD response to avoid GCP/Traefik 502 on streaming content-type (#9) GCP HTTP/2 load balancers (and Traefik in some configs) return 502 to clients when a HEAD response carries `Connection: keep-alive` plus a streaming content-type — because they expect HEAD to be a closed-body response, not an opened SSE stream. Symptom: external `curl -I https://.../v1/base/realtime` → 502 even though in-cluster `curl -I http://localhost:8090/v1/base/realtime` → 200 OK with full SSE headers. SPA's `fetch(..., {method:'HEAD'}).then(r => r.ok)` gets false → live channel `disabled=true` → no live updates ever fire. Fix: HEAD pre-flight returns ONLY `Content-Type: text/event-stream` + 200, without the streaming-only headers. The full SSE header set still ships on the actual GET stream. Applies to both the per-channel HandleSSE() and the multiplexed HandleMultiplexedSSE() handlers.;rfxatree de3bf981ef4194c6bd1abf733996872270b27eef parent 25c98516bb42a7a9e11a83decff8983fc90bdb2b author Darkhorse7stars <92065535+Darkhorse7stars@users.noreply.github.com> 1779420479 -0700 committer GitHub 1779420479 -0700 feat(realtime): add /v1/base/realtime multiplexed SSE channel (#8) The bundled SPA opens a single EventSource at /v1/base/realtime and routes incoming frames via msg.event off a handler map — see realtime_sse.go for the wire shape. Per-channel /blocks /transactions etc. stay for external consumers; the SPA only uses this one path. client.es.onmessage = o => { const c = JSON.parse(o.data); const d = this.handlers.get(c.event); if (d) for (const m of d) m(c.data); }; Wire: - HandleMultiplexedSSE() attaches a wildcard sseClient (channel=`*`) - Broadcast() now builds two SSE payloads per event: perChannel: existing `event:\ndata:\n\n` framing for /blocks /transactions /etc. wildcard: `data:{"event":,"chain":,"data":<...>}\n\n` for /v1/base/realtime — no `event:` line so SPA's onmessage gets the JSON envelope and dispatches. - sseRegistry.fanout dispatches both payloads to matching clients based on channel ("*" → wildcard, "blocks" → perChannel) - main.go mounts GET + HEAD /v1/base/realtime (HEAD is the SPA's pre-flight to decide whether to disable the live channel). Without this path the SPA's HEAD pre-flight got a 404 (the explorer SSE-HEAD-silencer from #4) and the client set `disabled=true`, so no live updates ever reached the home page.&CGxtree fdc48f3ac2b455d3f4ae846fa534011dbaa212b7 parent 41e84df01aaed72522e4ad2c0e3d00d723b47024 author Darkhorse7stars <92065535+Darkhorse7stars@users.noreply.github.com> 1779419718 -0700 committer GitHub 1779419718 -0700 fix(supervisor): preserve unrecognized first-segment when default-routing /v1/indexer (#7) dispatchIndexer's splitSlug peels off the first segment as a "slug" if it matches the slug regex ([a-z0-9][a-z0-9-]{0,63}). When that segment turns out NOT to be a registered chain, the previous code forwarded only the REMAINDER to the default chain — so `/v1/indexer/main-page/blocks` silently became `/v1/indexer/evm/blocks` server-side, a completely different endpoint that returns a paginated envelope instead of the raw array the SPA expects. The SPA's home page widget does `data.slice(0, 8).map(...)` on the result and threw "o.slice is not a function" against the envelope shape. Fix: when the parsed slug isn't a registered chain, re-join it with the rest before delegating so the original path is preserved under the default chain (`/v1/indexer/main-page/blocks` → `/v1/indexer/evm/main-page/blocks`).#u>xtree da4ba9c87520199170911fa37074680541f61043 parent e87e5b35c38229fa9063d35782e366f7d172e503 author Darkhorse7stars <92065535+Darkhorse7stars@users.noreply.github.com> 1779415778 -0700 committer GitHub 1779415778 -0700 feat(realtime): bridge per-chain block events into the realtime hub (#6) When ChainSupervisor.AttachRealtime is called (from main), each chain's indexer.Subscriber.OnBroadcast is wired to push block events into the RealtimeHub on the chain's slug. The hub then fans out to WebSocket clients (existing path) and SSE subscribers (new in #5). Requires luxfi/indexer v1.4.4 — pulls in the exported Subscriber() accessor. End-to-end chain: evm.Indexer.indexBlock → Subscriber.BroadcastBlock → OnBroadcast → RealtimeHub.Broadcast → ws.send + SSE fanout → SPA EventSource Now /blocks, /transactions, /token-transfers, etc. on the explorer host actually stream live events as blocks land instead of just returning HEAD 200 with no payload.TxWrSQ.H$DI$ʮVĉGR^d\`Ć]b*3$. d 잟|;*E/T6Metv)L˓B,iUӉ<!fʳ.OfB||r>B'I"Z_֖^ _.ы|:=>{)RS[Tt}fi^^lr2Nh4<]i/fb{y-)}DJ HHIƨnHxG5R^S I>B? [04O6UBTU&%5—.IeݼwuksE}6pa'^*C##aUҋ1+!$!*~k!R(ѫZxUmHd(+X iGs1{>EHl'. s5R777 ۻ `Ixz8tk^ϽM$7fG >!D Q~baKe 8NTZ u@lpEX`Q.tBocgP])CJ`JV]1eUE/Qz>:0v嗈hHR|Z!CP^)& ]œ'NU9]^%7wt 7( pCT5g›iPiWηګ=ݱȇn@b!q>(fc>{T8s>Lǁ" ;ó.yëq@9SRpH`omm#@i:E^p/@Jv@%={b1 ЪHUAW該}-GD[xb#@X((dJooI<$ن[m`ZԠkXF>0 ?(J']D F*bpڷJ]O.yd.~ܪn͜NaL9XNewbc/Zp[(s$O7м  7igM(E$Md$j0H|k9^3$]Hںrc1#TǹFyEb|Cq5H@YiC=ԜאI/IׯNmPߨu8;HqM6L73xVн7k+ V +V(% mC+ؾȗqqyo{֣ c,kت}|ҹxt80d +QFwٿ=ԏׄ}; *,ځ+qxlhx+6XKfJA24's1nVUX| Y`4[,AB#U,ahYp8h֎}؋Ǝh5Jp;$۟_{BGI+m|+7 !O0ưWV }<+ې!Y{ڀڠ,qaf8?vI 4*D:qpwbBktGڷbo} k^ނ,.VWy.2&o>La71:Rz)lkӒ &?h^}W"Vg 6{\`]Cv{!0Ȓ ᓠ#``TfhP~%Z &%!%eSxTю4}W\RۤHTj;׍U.;,Bڏ=^xJbs|ιXbXM[fU]]7U5rJm=WJjTuSVe]s=m6/^WVK\ y3{b5I;c__|Y=45H1>g.w(Q b|ڻӾ@[I碋$)d%GgC^}j q80 w˜?n:vBJ)~9abrx-Y 1779222063 -0700 committer Zach Kelling 1779222063 -0700 ci: switch workflows to lux-build (luxfi-scoped ARC pool) Cross-org runs-on dispatch failure: hanzo-build-linux-amd64 scale set is registered to github.com/hanzoai and silently rejects luxfi/* jobs. Switch to lux-build (githubConfigUrl=github.com/luxfi, max 20). bkx tree 2f2a5c66dc9a24f0e4d8b934ddcf08160dfbdf2f parent bb4ce667525c70dcd3847c2350e3f72bd32a72ce author Zach Kelling 1779205220 -0700 committer Zach Kelling 1779205220 -0700 ci: rip orphan replace block (graph + indexer sibling-dir shims) R;xtree fe946c3655d13d622306adf8142fa975c2226355 parent 7e82c67661a4337c6f17cb9ffe90e9296d85ac5d author Zach Kelling 1779204815 -0700 committer Zach Kelling 1779204815 -0700 ci: rip ../graph + ../indexer replace shims; bump to graph v1.2.0 + indexer v1.4.1 'Sx|tree bb7107d16c636d6f9d677cd8ef75176724440b5a parent 8f3d58ef5e21746b661c4aa62fdbe7f2cb7fb901 author Zach Kelling 1779202927 -0700 committer Zach Kelling 1779203016 -0700 ci: fix runner label (hanzo-build pool) Imaginary runner label `lux-build-linux-amd64` does not exist. The live amd64 pool is `hanzo-build-linux-amd64`. - docker.yml: docker job ]yxvtree 1b601c107e5b2b5127157e64b2b0a7da33b69766 parent a18fcba81bd9105100c3616a89b6e29f82cf1a33 author Zach Kelling 1778953747 -0700 committer GitHub 1778953747 -0700 chore: add LICENSE (BSD 3-Clause License) + LICENSING.md pointer (#3) * chore: add BSD 3-Clause License * docs: add LICENSING.md pointer to canonical IP/licensing strategyNqGxtree 840c342b50cfd524a73f5fcd9413e28594e3e367 parent fb37b21f0c8a010be1b23c6e58f4614a35903470 author Zach Kelling 1778698780 -0700 committer Zach Kelling 1778698780 -0700 deps: luxfi/crypto v1.19.0 ^Bkxtree 0397891d3eeabb15b99bfad03a75e845514d49b6 parent f2410a95ff387bd503d004fe04ed165da8302db5 author Zach Kelling 1778646558 -0700 committer Zach Kelling 1778646558 -0700 go.mod: bump go directive to 1.26.3 (security advisory) M^x'tree a84952a30b356e5c7a51e88fcc1b6daf11828d32 parent 875af11d0487f71a18e59cf4e762429882794d4a author Zach Kelling 1778089515 -0700 committer Zach Kelling 1778089515 -0700 ci: build multi-arch (amd64+arm64) — Mac devs run native arm64, no Rosetta Matches lux/graph + lux/indexer docker.yml. The unified explorer binary bundles SPA + indexer + graph in one image, so this is the canonical multi-arch artifact for the local stack and devnet. x tree b1c7ed692ab2271e3f30a430260c0dacb79a9888 parent 50fc1cf497fe4d0c7ef889687aeb0b96d8ca1e43 author Zach Kelling 1778045579 -0700 committer Zach Kelling 1778045579 -0700 ci(docker): amd64-only — multi-arch QEMU stalls on heavy SPA + Go eRxtree 5fb3ec9b9f4ec2dcf69999cd72a5a5b490e7e538 parent ceaf8cab7645620700b3af2eef5ae970d978b2b7 author Zach Kelling 1778043245 -0700 committer Zach Kelling 1778043245 -0700 ci(docker): go build -mod=mod populates go.sum on the fly Oۙx tree 7b59cbbaa57ea015fe68d85dac4d25345445750b parent 7844e67ea67becc296ebebb080049d3be66de03c author Zach Kelling 1778043048 -0700 committer Zach Kelling 1778043048 -0700 ci: drop ci.yml — Docker workflow handles cgo build via alpine Sxtree a2df3925c59af70f8680d33b1bc8888e18b55537 parent 6b5450579e07bdf21e2f5c5ca73913fe34b83972 author Zach Kelling 1778042662 -0700 committer Zach Kelling 1778042662 -0700 ci: ARC has no_new_privs (no sudo); GOSUMDB=off everywhere mqMxtree bad4bf082412b6cb2f5223dd0be204330b9850ee parent b50a7e1be650ebb6d744d60c5ade23453117ab17 author Zach Kelling 1778042082 -0700 committer Zach Kelling 1778042082 -0700 chore: gitignore .claude/ runtime state Ixtree 860487c5a72962cf6ab735df02dc6c8e3e119326 parent f86302117b8f6e25dd24d17c6677d4df62ed7471 author Zach Kelling 1778042065 -0700 committer Zach Kelling 1778042065 -0700 ci: regenerate go.sum at build time (proxy cache inconsistency) P֗xtree abf969e54029a2f0e07558ff0fe2fe26203f078e parent cae33f0789498a01d67a1898b949308edc115814 author Zach Kelling 1778041088 -0700 committer Zach Kelling 1778041088 -0700 config: full chain list — all Lux native + subnet + external Pvx tree ab972f511d87cebfd24c8fec81cf93ffc1e27d23 parent 598e6f6004afe10dc906e2f146304df023db1744 author Zach Kelling 1778040880 -0700 committer Zach Kelling 1778040880 -0700 ci: refresh go.sum (proxy hash drift), install gcc on ARC runner Qj#x3tree 0fc515d6feb88821662d1b110955301bde2fcc95 parent 8698aa8248a73818884fe7d68ccb95cd2145860e author Zach Kelling 1778040555 -0700 committer Zach Kelling 1778040555 -0700 fix(go.sum): align hanzoai/replicate hash with proxy.golang.org Local go env had GONOSUMDB=...hanzoai/* which made `go mod tidy` use the GitHub-direct hash (YxjIynl…). CI fetches from proxy.golang.org which returns a different hash (5Rl3…) because the proxy cached a slightly different zip layout. Replace ours with the same value indexer/graph already use. A ͔!xtree aa632e6aa6b40cbaced617b1d2f1945e97b3087a parent 0a97dedfe92493674e17c0b58ed2b2c3b0439c69 author Zach Kelling 1778040340 -0700 committer Zach Kelling 1778040340 -0700 ci: align with luxfi org's actual ARC pool (lux-build-linux-amd64) Mirrors the luxfi/indexer change: switch all workflows from the nonexistent hanzo-* labels to lux-build-linux-amd64, inline the multi- arch Docker build (arm64 via QEMU), drop the cross-org reusable, drop the workflow-sanity job that referenced cross-org actions. ^ҟ\x0tree db2b2f2448cf0d23ad32c220273256d39a0a16d4 parent 9fa3cdebd3762216b1d0982ed5c02f7534026d3d author Zach Kelling 1778040232 -0700 committer Zach Kelling 1778040232 -0700 unified explorer: single Go binary with embedded SPA + per-chain graph Module renamed to github.com/luxfi/explorer (was -unified). Imports luxfi/indexer/{daemon,evm,storage,explorer} and luxfi/graph/{engine, indexer,storage} as libraries; embeds the luxfi/explore SPA via go:embed all:static. A new ChainSupervisor wraps the existing ChainRegistry: adding a chain (via config / mDNS / admin API) spawns a per-chain indexer goroutine plus one graph engine + indexer per enabled subgraph; removing cancels them and frees the routes from a sync.Map dispatcher mounted on /v1/indexer/, /v1/explorer/ (legacy alias), and /v1/graph/. Config schema is fully per-chain: indexer poll interval, list of graph subgraphs (each can pick a built-in schema like amm, securities, fhe…), brand (name/coin/accent + on-disk icon/logo paths), token features, and top-level networks list. /envs.js exposes the chain list and active brand to the SPA at runtime, so a deploy can rebrand by remounting chains.yaml + assets — no image rebuild. Dockerfile clones luxfi/explore + luxfi/indexer + luxfi/graph as siblings inside the build, populates ./static from the SPA build, and produces one binary. CI checks out the three repos as siblings so the local replace in go.mod works without tagged releases. .ux tree e9ef4f120b79eaea5dcdbc67fc3b7a64d84a2f64 parent a648c0b31dae1dbc158ea33ce8e113bf105f2d17 author Zach Kelling 1778036879 -0700 committer Zach Kelling 1778036879 -0700 chore(.gitignore): proper Go ignores, drop rebuild trigger comment -tTyxftree a1f2c5fd9e7fc38a9e762f7514b9a9a8e6b4a78d parent dd138bd8aa56ca14f14bf0c9ec64f575da85633c parent 071cb269f28b479185f3b88ac9b7c1227d8cc529 author Zach Kelling 1778036368 -0700 committer GitHub 1778036368 -0700 Merge pull request #2 from luxfi/ci/multi-arch-native ci: build multi-arch (amd64 + arm64) on native runnersogxtree a1f2c5fd9e7fc38a9e762f7514b9a9a8e6b4a78d parent 8987a18472820f49e45846601ca13727de414f3a author Zach Kelling 1778036307 -0700 committer Zach Kelling 1778036307 -0700 ci: register hanzo runner labels for actionlint 5Kȟxtree 02aed7906e41349de231ca755ff5d96fc6f8daf9 parent 911aac20a13f99ced64e81f223c37f9e6fe95887 author Zach Kelling 1778035887 -0700 committer Zach Kelling 1778035887 -0700 ci: use hanzo-* runner labels (sanity) H\x,tree d5a98873ed8293956340c809fffad804ae7a3d36 parent d74c06d00beb8ca378a1c533c4aa1f83ebdeaf1e parent dd138bd8aa56ca14f14bf0c9ec64f575da85633c author Zach Kelling 1778034163 -0700 committer Zach Kelling 1778034163 -0700 merge(main): keep multi-arch + semver-only triggers ߯\xQtree d5a98873ed8293956340c809fffad804ae7a3d36 parent f7d11ba9758f6c02c68190c6d333b87651518536 author Zach Kelling 1778034119 -0700 committer Zach Kelling 1778034119 -0700 explorer: remove branding cross-contamination Drop the _lqd._tcp / lqd / liquid daemon entry from the mDNS service discovery list. The lqd daemon is the -side white-label node binary; the OSS Lux explorer must not advertise it. s"GxYtree 0b695143561ce964ded453a18b176ef8db3bddc2 parent dfdb3052c3e00d7fd5c9d874d8cc4ba006a0b130 author Zach Kelling 1778033309 -0700 committer Zach Kelling 1778033309 -0700 ci: build multi-arch (amd64 + arm64) on native runners Drop branch triggers, semver-only tags. Pin lux-build-linux-{amd64,arm64} ARC runners. Eliminates the amd64-only manifest that crashed Apple Silicon local k3d pulls. D%xtree 7fd06b2687f41531672d96953f410837b9ed557f parent 5b7a59a72544f95af0569c362a1bf59f95825a60 author Zach Kelling 1776997394 -0700 committer GitHub 1776997394 -0700 ci: migrate to canonical docker-build reusable (#1) - Add docker.yml using hanzoai/.github/.github/workflows/docker-build.yml@main - Add workflow-sanity.yml to enforce canonical CI contract - Remove bespoke docker build steps from existing workflows Refs: hanzoai/.github canonical Docker CI contract.]Qx tree 7fd06b2687f41531672d96953f410837b9ed557f parent 5b7a59a72544f95af0569c362a1bf59f95825a60 author Zach Kelling 1776997280 -0700 committer Zach Kelling 1776997280 -0700 ci: migrate to canonical docker-build reusable - Add docker.yml using hanzoai/.github/.github/workflows/docker-build.yml@main - Add workflow-sanity.yml to enforce canonical CI contract - Remove bespoke docker build steps from existing workflows Refs: hanzoai/.github canonical Docker CI contract. )xtree 05ec30403163c08342bb6aadcf78f72d50d2ce55 parent f8f1175eefc2deb79d5d410883e6761a418b092e author Zach Kelling 1776374133 -0700 committer Zach Kelling 1776374133 -0700 ci: docker multi-arch build + semver release workflow MҜxtree ae8c1cbf01a3c4ef3b64f9442bedf313a5697b83 parent 31826b92f3b17083149b3521027226ae0719d6a6 author Zach Kelling 1776077660 -0700 committer Zach Kelling 1776077660 -0700 fix: use lux-build runners, not generic self-hosted L}xtree 67410a2f862abb06a0545f03e1f65d5d0e6869e3 parent 6fa377ca541927cee1d0ef682ef213474c1394f5 author Zach Kelling 1776073381 -0700 committer Zach Kelling 1776073381 -0700 feat: use info.getChains for single-call discovery (no per-chain probing) tTgxtree 0ff63ccea78bbb19a3597efae560484f7e17f0da parent 5a66ed782a87a3677577552d1cd27c55326ac3fe author Zach Kelling 1776071785 -0700 committer Zach Kelling 1776071785 -0700 fix: probe RPC before registering — only index chains this node actually tracks UYx tree f80df6b97507f299c3c70d1c113711d00044b827 parent 45230c0b273977852c9c30a5213ce27bf43037d8 author Zach Kelling 1776070690 -0700 committer Zach Kelling 1776070690 -0700 fix: fully dynamic chain discovery — zero hardcoded chain lists Qx tree 09f49cf4d3adc4d8da4b7a14c67d34add2510c17 parent cca50859f0645a03a0885679c96d588eda838b20 author Zach Kelling 1776069740 -0700 committer Zach Kelling 1776069740 -0700 fix: per-daemon chain sets — liquid has evm/dex/fhe, not C/P/X 9NQQxtree 3a06e8dfee3ba02cf9b38c1052b2b0a3bca08186 parent bf584f6b48f9d265640f12d162b47250d18b1699 author Zach Kelling 1776069577 -0700 committer Zach Kelling 1776069577 -0700 feat: discover luxd, zood, lqd, hanzod, parsd via mDNS ZM'xtree 453428f8c721029ab777cb81e7d366459207548d parent ed8fb4b646ba370fab3b53583760b376f53d15b1 author Zach Kelling 1776069391 -0700 committer Zach Kelling 1776069391 -0700 feat: runtime chain registry, mDNS discovery, /v1/explorer/realtime Runtime-mutable chain registry with admin CRUD API, mDNS auto-discovery of local luxd nodes, and multi-chain WebSocket realtime subscriptions. Config sources (priority order): 1. Admin API (POST/PUT/DELETE /v1/explorer/admin/chains) 2. --config chains.yaml 3. CHAINS env var 4. mDNS _luxd._tcp discovery (lowest, never overrides manual) 21 tests, all passing. 2 Θxtree 200ce12a53e92c05fa83f229e3fa078c9b474bce parent 1a6d559ccfc01cdd2521511839f04334772dc735 author Zach Kelling 1776010884 -0700 committer Zach Kelling 1776010884 -0700 ci: trigger combined image rebuild UFx tree 80e2a7ada6b68d378a94574f2119a05b13b746d3 parent 7ee5150d270ca574c8e8f555a7048da9564df2bf author Zach Kelling 1775943083 -0700 committer Zach Kelling 1775943083 -0700 docs: full README, compose.yml, chains.example.yaml, healthcheck, CI Q$xCtree 7dff837e60515e0be8a2360b832f716818c1a67a parent cd4378e3f92324cd031ab01fcd584be7242e23d2 author Zach Kelling 1775940607 -0700 committer Zach Kelling 1775940607 -0700 feat: include graph engine (subgraph replacement) in combined image 4 repos, 4 images: indexer → chain data (blocks, txs, tokens, contracts) graph → subgraph events (swaps, pools, DeFi, GraphQL) explore → Next.js frontend explorer → all three combined (this) Single image contains 3 binaries: indexer, graph, explorer. Each can run standalone or together. ߿_xtree 30ec1903c50c309e778ff050ac500e7a227274c6 parent a2b779c20cbdce6ac8edd2ebf2a5e89e307f588f author Zach Kelling 1775940007 -0700 committer Zach Kelling 1775940007 -0700 fix: use pre-built indexer image as base, layer frontend on top Q%xTtree 65df319ce49c0c030046fb802b76864890d0b6bb author Zach Kelling 1775939328 -0700 committer Zach Kelling 1775939328 -0700 feat: combined explorer image (indexer backend + explore frontend) Three repos, three images: luxfi/indexer → ghcr.io/luxfi/indexer (Go backend, API + indexing) luxfi/explore → ghcr.io/luxfi/explore (Next.js frontend) luxfi/explorer → ghcr.io/luxfi/explorer (this: combined single image) Dockerfile pulls both repos at build time, embeds the Next.js static export into the Go binary via go:embed, produces a single container. uVNx31̒$},ޜƖS9MC3TsSug0_a1'#1*k{up^=3ywO2+o|jK~rvjQZfN*o^V-~\ú%]C,X nK_z84?W7E!z }l?˷%sU'( jj_:K㌭W%B ,8ǫwM)`# 5f 3Kf[ՈqcNw{Z~´'Z,]k;_+$%pxfd4F+Y+?+9kn Yx{s msPG=3țEZי(2Ak[/sZ>aXhs Fa+Ċ_N[*{ӯSYmv!-gPW'Jy%%z JLogږ!ޔ#S(Bx340031QHL.+ѫLaP ]9+PTGn[7Ps3(H-+.KgOGո>~rˋ.vc[xN]fv4+dzx+,x:self-hosted-runner: labels: - lux-build-linux-amd64 D8=x% explorer Lux Explorer github.com/luxfi lux.network A11}xMNAN0+VyChRqD&YVmoeor`"XY:f|]ϖX+RBQቂQ<ʟ8ٶcp8ųVY˞7IqOEꊗ|9[PMVʺN[P(; ܣD^c/t\z9#B ]ǣvlmLjjϨ Z#?tbh 5sgh5''L8JgK]{8ބ2MYn&S/딎W~g.uASa8O^{'Q68 Kp2&+|ihB<#+0A6u!8oW8 +8(ОG&Ҥq#3v5h~ a)5RP.LrjCD"䄠?;coS,-Z=uuڍdU g0Cmh,K->&D.]Fr{BM'(pJ(5LEZ. LIvt죚NretɁzbbI1h_x\P!Ƚ:9 lb8VQsvcc(w;Wq=:xWU A^"\Y{&>%^@KV2sN1!YI/HP*jЩ3^M`H茚d0k#WSܭ"= +[V}(+NkSEFȢC^'gӫÛ~Mx@i/\tvH VU D/rq4# 8.oKjuoZg]JkGwN?Ԃ=eG2TP'[ iexXbPr2U2C1EDԏ F@.eԾSѨSE#nT+Ck{bi[괲piO^bc+N)3JSw9Ė^9_M i %xx~h*MBAyzP2d*cD,QrIJpr\ղZ`_w]ZBmT;TN㹋 J]YPyU̝K然*9ы d,bEfA/a!JL_8PR,b h^U@ Y?9R|ʹbD5k7ϳVc;UmZ7<{w\uPd"I$yᏸ)F??Ɋ=dI9,IT1T|#-u4a9Nm 4<;^ND5㈪ns 1G ڂJݍXXr43I(il{ W)nĢ(]-b%YU/>]wί.2J1*eo@qN˛fmV-{{eOy48bZUcw n m|]b>w>ȍ05җ/wvޯ-XPἒԺ_xBSD 3-Clause License Copyright (c) 2024-2026 Lux Industries Inc. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met: 1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer. 2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution. 3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission. THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.%x_# Licensing This repository is licensed under the **BSD 3-Clause License** (see [LICENSE](LICENSE)). It belongs to the **public** tier of the Lux three-tier IP strategy: anyone may use, fork, or redistribute it, including for commercial purposes, subject to the BSD 3-Clause License terms. For the canonical Lux IP and licensing strategy, see: For commercial inquiries that go beyond the public tier (e.g. private moat acceleration kernels, Eco-tier patent-protected primitives outside Authorized Networks), contact `licensing@lux.network`. ՐxXS۸]Nڙ]bM s(:s&Vl%Q-Wd'PKoW"YKUY+{.fl݋f7x٬z.XҹvŋXWxDvVc]r5R7ԭR:$]fB>fe5ORIUf¦TʚT9ћ2vg7Sʒ6u]a5Mu3U^`\OZWs%:ERՊlҁO&3:R$33JH$IlH+ nsc > :oAqXT);w%N3ve*G:XnVNt(9=k˖!"s5PLI<`X̸lt(ρH;U4[f.@;|kv{VʹAG]زn$Gj+ElX~c]m=jk}OeIEWiUnf|r\Hd4HеsV#sʜ>o B7=װzpyBVUS\'g'A.'=&ްW^No짭~ف֞dj!\Q (N8ìG%{zb&d;^v<HR.G@`Ĺ`z|MUKk:JJk)GwpL{ڥsHNFo1Lp ˦6Фqޓ"Z&7hO,ic־]iMb!#R4/&:q -A{[lt.j+? Yw ky)ioCK!D';ݗ Ӿ\S;[([5>].*\7ʍ|@w(B뾾77q 7Rmm0ܲn`uhgHeyaV QHӌx+gj^ htfwd4>߽98I4\O1!_t_̢u'9'U}5ž̀{wv%l]l423{o-v jNa~ X>AZTWoq&Q|V<ދ":&kRJsv NX3 D3G0ܛ`7 Ymd ;0ܴ-;0ĩ}"Dw`ݟP1|/qۘjo(tx}FWteaФ| 1'^"Ś>B͇H;!Z Sմixkpackage main import "testing" // The SPA was being handed the address the SERVER dials. In-cluster that is a // service-mesh name, so every browser hitting explore.lux.network got // http://luxd-headless.lux-mainnet.svc.cluster.local:9630/v1/bc/C/rpc — a host // it cannot resolve. RPC (what we dial) and the browser's RPC are two different // values; this pins them apart. func TestBrowserRPC(t *testing.T) { for _, tc := range []struct { name string in ChainConfig want string }{{ name: "cluster-internal RPC is never handed to a browser", in: ChainConfig{RPC: "http://luxd-headless.lux-mainnet.svc.cluster.local:9630/v1/bc/C/rpc"}, want: "", }, { name: "explicit public_rpc wins", in: ChainConfig{ RPC: "http://luxd-headless.lux-mainnet.svc.cluster.local:9630/v1/bc/C/rpc", PublicRPC: "https://api.lux.network/v1/bc/C/rpc", }, want: "https://api.lux.network/v1/bc/C/rpc", }, { name: "already-public RPC passes through unchanged", in: ChainConfig{RPC: "https://api.zoo.ngo/v1/bc/C/rpc"}, want: "https://api.zoo.ngo/v1/bc/C/rpc", }, { name: "bare service name is not public", in: ChainConfig{RPC: "http://luxd-headless:9630/v1/bc/C/rpc"}, want: "", }, { name: "loopback is not public", in: ChainConfig{RPC: "http://127.0.0.1:9630/v1/bc/C/rpc"}, want: "", }, { name: "RFC1918 literal is not public", in: ChainConfig{RPC: "http://10.150.2.1:9630/v1/bc/C/rpc"}, want: "", }, { name: "empty stays empty", in: ChainConfig{}, want: "", }} { t.Run(tc.name, func(t *testing.T) { if got := browserRPC(tc.in); got != tc.want { t.Fatalf("browserRPC() = %q, want %q", got, tc.want) } }) } } ¹xXn8笠hL-M6nIj ms#Rr! I搔,ڱ6M%P8e"_Yb?i1\]IuIa39_Y&dBc(r1<|Q!Hc DIFLSga7 k 4LkC_àusBLycq el u۸q>mKrt5歆W'+(NKGVp3*(Ʉ*Êt!YdHs14 'sO(Z4ǙȦB;~{8mN#$flͮ\QPa>֦YY655x,3zNo)OsT,aI|~uSBt`@k`߭3e*O(8DL$(F_Y2R؝( K+רb)$&S3iΪ7ywxs%8n0uɳɶi=5!1F*J3*\4cZjJn(q<H䨲Ą-sPΖf QfMlEaaѬߡ.v MXOph/qHڱdVHlJVj j/[jX+Y 7j17v訓˥t=^ALY^ܗ/e .Ge(3͎8L?]fɱY[f8:O1Z}>̀cݧ}Ƨ(駧DRwg8{ 0Ο)8.qp+cƔrLxy &;;E|hUJ EyReG&~풍yIglzW늩;ߩItHPYK'6. l_}+1nq[WDWe9j~\a^څgjmgXxik%CSqʁoG`t`6[ryǤyxz+7r^),7pWmQ5ײ8ƴB5ve9\!apq zxqW)Sf^~t_ 7/ BDĽXVTnCGswho@[('%>Hh_UZ`29v@{IyFL;n\t˯w{oqfHFs ix}=(B}kn3?kBs}C@t>. 0>QJݏ]-G ֛kiúebD’c0d5np#݉ShniΆzC{N 5[D\Ei%p(^OǫQf.௏xgTahP5L+t=)uϊRϤ?y s*n4"Ld76! Y [xinAp&\l8A4cxN\! <.Fp Xxm0/ Q$+(\ZR__fي/Q4#1 Sj#ɒ[D L~"l$vv;&x44SPC "PAxUQAn0U[KR"#r6A1eJ_pj/xwfm -GKP͌.}+J:sw4_@ Ɋ$3W?ppNˏ)48xVƭ|eA{8aQ2"o6‘uZ`:A :N83F((١tKӾNTdyߜӖt~$oeġu;rdO櫛<>=~~vuoUuwIR>*?cॿ23@/ZZ&kI8T ĊG%x{timage: ghcr.io/luxfi/explorer:lWDATA_DIR: /data HTTP_ADDR: :8090 EXPLORER_CONFIG: /etc/explorer/chains.yaml8)U)xZrǕMAaO >ʲl}~ѷ镝:3y׭9'_῵ۊ5mS 﩯I^v^$Q7羜S79jXkW(|jʄEmܗ6s~nh!kİ"m]m틼6\rI?Ì,޿?{e:}YVS8Oi wz#3Յ]g&6gϞ7ڥycQ8_-nbEk!rYsES>Gy Җag?>cF {55/]ci`©1LU,Sz(KMhZ?%6I-Gl [ۢfрn;"3]5f얾yع |ӫwgGQԘ1c =[U\)HS"T6. ,Ɨ'Tcc2F%FWXѫ&/oE*c5UT>}dtt` –v`y@17̆\Ә?:7g>y~ÔyUS iۙmB 箙Jmm69 ix&uzIS[|񣣁P;ܟƘ%/O_qo;8ft`FAl1.4(ᆒq@O㋌ˉ90dqإ\"ff 7yL~Y䵛m_:ڲiQdiƾ(!KOO&%ch9J䲫ү` vD jxQ,Ʀ6kD/"dR!LL,+K̩3JmQKSoij+(@pG00[̒lj *h!LχR Fa z_?`;oA )Pnu}n*x8ǰ5YpRԊW1}Dؾ[ !]JxTubC嫼O` "rShz- Э"'hd.}`à4B-+MBq aya+o52k2]4KAJW^8B<*=s]t9Qp׻c?D!թp]Rb?G(^S: Hmr?8K`9ҰAK"u\#ڭF8y)A$o ‘}Y8xEGF]cTՅ897;r9A?~Au-c FQӈ)XvɆf˦bX])=ekxZQFずLA5f@;k8BḞWh Ii17AZ";/;y7(,jLPr$d-&\xӌD#6h3I5.B "ަozUAȦϊߜ ܡ`QkIBR^H6HnPeў?1D[*3+2:p.HlS;uvx*8>x/<3|Ujx|;pP\K2 [e~N% 1,p }_ʐSAZF>$ɢL^3s)IwLĘ)Q#`e%4k` @G΃I(q4Pq E:ļm, cA (װ2'З'Xwt~3 CȁWnG2I[dh4?@d~9 0Ol.T~j.Kd:T~2ʇq"!*y$ޖ&T[)i/PwJO㇨#Ãdd]<|x3:Lʇ)]8tIE!̷VGYے+8 ؆a5e+}C/QG[R -GhIbEU 4;#*y\ё]W0A 䛀#s(c(qLj/eP 5{ѿ>$$rF( L?0>=|;`ܙ9yjPy34=='\爘J:K$(=Ck=,0a~kB9g a/sr":=-LLi}}ޟ##ŷCb8lRˆ8xlBq/p Hs ]Y\|"9PR2\d <+8hweqgn-hߑ;x%@ַHv:EgDQ ADҋsH=j(xqb Ta)⢆p(x CTx0kf;V&eRt Do `oh\DtŒ=D1(q pn8 ° ?p w c•ѣ̟ͣt'Dv #*#C͖( ay2/-.!x$_\H h0 DN3Z8J&_Xeu[^5ڱFd(p6C1=yACc6g5M?!&=@*feܐ`#htBE5h}nL9䁝KpOmtg ⹭?DYêZG͎Ns@"%⁍2FCw(;qJ,1]jLU넴w:pB}Ǯb]!䷇ _}C)>suef]hማTQ)$Z՜98 as)י5=Vh:H&Nb;ۮ7Jȩ̖MF9-P NpT* \<'ʹqV*S\~)hzjvSVOB^V[&kkHw_ =X D[n~3k|*|F4Q} |^NY*d)6.K˧DxXZ> Routerk SwapRouter02 — the contract a swap // is addressed to, and the contract an approval grants. One field, because // the two must name the same address or the grant is spent on nothing. Router string `json:"router" yaml:"router"` // GenesisSupply is eP 5kAd J9Vr yjhUhC$CZ{Xd |Ff^s~5kY-Ǔ)]9]cOQ] *k6<6S4-@;C/  -?< ̋ğ-=w!K`y+/}?v(+(g58vE4Lc%wuH5s7nbU,""a2_k/YSX/R/s10nO*vo,b|̼,4#< (qنAS=,Lkug;Vx9!4c4㪿Xֈ_ u٭(0 ߑw)O } !a xNXeeQ=/6a̾Gn2^R Y'DSo[a|0 o;!|. 82CPso.k>!﯑yǑ@4q-û$ }M޹guYmE+<xuKMa4XzZtd_=*}|b N.-5ViPr|shGDTLx\rr-=,*Y6 ɻ,*[JdY%ڻ'QT6EX +Jq0${f0 )["xWɥV$+ټnoFg#=_gǺ,b2k#+w&<Ѝ3m}Q1L\`Hh{{gGMdP*QcԵnjU_]eiYǼ, $G:ViD]?wU3R"nUQҤRWյ󋼤yihhxI: @U&\T\u^y^t0iZDOeuyoch?QqY>F pҤI}ڙjJz4eHg֮jcfX.3bz~zTG=3ILB?=68-Ftgx^fך-ixbUfQп候huR<> Ve9D&iEV{,]?;E5I\n7srS-F}"+#'zLpZ4 TjD1jJKeoOEC A!AOU+{T$ZUev?v6\BDz*_>m S(ܒ lomoM['hU-:YaVp> Iu&aX;77^6  iL_ɮG5!2u&e0ϣ/CHx1CI lf=@MH'}- zUY5c}jݎ3^36Dփ`$(/"JH_E유[&M;B7ǮFLMC+@p{fph-'Z6%HRB DmMuk狚uiĘGRNK@ u Z@+Kxō1'X+x rjt͑g'kĽJQRlq$׋>:~:fo (z3~Dn ?W4H 6K$]?V?/9aO0 n>H h9=bW8Z9LG$ hr՚ Zcg+h%4篚 Gv~='S\'Il_'( Яֺg\^5t!QHBsrxlF#TMB 'H"i1"ɇ,cyK:ƆCcx| FNbWN*mb񀅷jr(1qZ<. m ܐxE Hy qnjeGs0 if$h; ϋgxgBv8.=Йkatk "y4B9Iϛ YYH0:&db9X`ͦⲓJ5ƃqjpFh ,$@2LUF=67,&|y_ƯhVD }ƻ%יd%G<hQ]9lё'z @%Z;r9G.imJd ^=$j6.IqdoNm-w I%W$(PŅneuEݔ7!󲮳 1 |`#TPٌ6N`"!5!gǼoy—i!xbxD #"H]p^x^U KxqmuL "שC;=t1|K F[iaEGl{ޔ h:ƚΒO?'Sۑ,= ,E%.b`j':1I֚COFyvq4/pPm%nIۊV:c' *U01qQA|ZWXr# ~9z{~a0P s#N1f-}v'VBxq䥿r2wvvp.G6W1y+01%W^פ.I"ɸ-.h1-~ѥIh!& Y1./D{?7"ц)4s@,+uRU6ousQS6FQG».GlOK< šļ:˚icpMSv۰l#(ܘ5/d' ?w'&'bu԰= [ Yf̭T fg5~#?٦eV?$iJ/}yߡU+1rAȷNVC._8"& fG- Q5p|:Ɏϼ&>^(i5[cg37@JlvЙpcclOsu/Jc l>uR _Z:3LFLvq5 ,I렏K"%/b9 xQƌ(x4QLxyք֑.zЩIidL!OxD={tZNIhc#-De`t*wH1=&)dl*4=zi jbʼn݉D4cf ,*ҝҡ7y.<ȑWZ]6H8_w1]X?JmomHڳ_M*ysnYM~u<(fҫR>y֜= $|wFr=N }d) [N }c\(ٻXzh'kCM((Ʒb2s]lWxLȀKޢit3% I?5#pqkA' duΑ/u`Ͱ&ա*D}C8Ph)`/=&}%m2 h-leQf06]pAumXӔx-國l^">oafeӒoBבe7CBX=ZmmP R&vWI%mg䱅*ItQ:%饒=G4Ǖx3Ӟ-&IsQD6nƲW ̜ǪO o{3!:rv%EI&#i1ɇhPȰm)R6 /m${G=}@@ئG܁HTّ%2*#$ÒvsL k:S*܁s(C|ⱁVB^>)>]\BUc<ƛb߭L1bM0x a}n,OGK?Sԛlv$&]+uFe&Qu?fL="PH_ h2R#6֯ 6A2H{+ Ba +y;!w= ~ t*Ls,}}i@;S"}>$>EV#m[%XZ& AC_hl_8uaqkO8璡в eD.Ո v;iqlB*wg_Z\sFF&&,[ϟ!|ń(a}ulu֩6;ԥi-.yRi&ad{t~bT{XO>͒ۑ~g¢yنO~ު y?z4u<M7vt=\ FGsz!f62L 09dB0rb5!wN'Rז+owZ;دss4|6ZF?EAi=I>&#&}Ve\bԔWL~C.nBz;dblg=gdd](L/$l{xZnm=Wmi+ ]^E.6 GzDNHJ_}OOsxMm7x.hxAnjLi[d IL&ZgofJKߌ NR?2c3Z9RpxZ's&8a #`@ iɯyBQ©"` ~sNsF(6W ޏ^1IP"ID ӏX2NL32H6Nۃv#tK=P$PXo +1e4RL&F?>ymY)4sИ 봡=Zs^u_18C``pΑBާ! Mp>Ȃrm;8"b1EL4dNjU BKtFfbZ}rJ3p th!ɲsA9 cab&PH1XI ЂgJ:,\05IHr>a Ra1Ѐ3"1LAO,Ŵ YQ!Qb]l&fY]LkDP:xt`"wCۃP]ii?'wnK#Icw%jMa60HLaT͠!!oݶtjqgy],{v(_f7TX^ORZ] ia~pwET9my&8# &V`&<8>ex3PL؂#>_U՛ӣӏgOIb+,TNdO45=&A 'lќ,||ds" ZaZ/eku#LUY]n',H*b IثeB 2Rz6L9^66Ϸ,qkrc,}[tH\ WP;6#kL4{fK `Of&0 ͘L5pHd*|e>aC &%M16d|wl+=VLZ9iE6{m>fI,B&0:ra`j%Zqٹ>U9qpA!CA8_Oe♬\X,TAtAA!UhLm@4 1\}ɥMo f ÙFb.H3f׵m"*}SoNU0`i^0ͭQo78e!:-0UY[5DŽ+/U`u:':-P&*cQ-X^"QBiMzޱ5rQrΠU 6h<Ƀ&A*FGt3L=enGiFiֳ#Oe;m:rLӔ(N-J=7_pps.4KYi3)bWA'& Jh> UBQrd, Chq9LQ mmTxn\= Tvv2F+pgulH嶚 e"^D^{-դ4{eξB"0'W$EAܐ^Ff%O ]@N g1{mCeiOkPQ%A|׀OȨ2Íg< QYw@"*:RubIx~X2outPJGA<❐b4ә 0>{>M_,Obs,|_h/\9 7UKLN^/S4s`!S79˰DHB9nxճaN)UQ1T]u")nO7q(&͝b¦ؾ_+j&n Gjγu#f;aXOg"[1HB* w]"z-j?#vae1RV=&H=mMx o$I ڛ8++DN+kQXSu^2U$L13"S Dsb FAAOKEj I:3BĚ^qԭߪqAFue16Y:mZ'l#sdez$4-Nit'RY) Upn):ɊeW]<3_ޘ>8h^I_FcɄqu3n}22^ ex$/%,lq8BrxN*amSF%!7%5W; cM(ϻu/\/;J+`Kiq _𮵽ox]0ux\2/n&+6* H P'*IYfDw p{7W99FEpH٫! <⾒oύ%Y15+^ӰiaW̎!a~x򞸿 )h2x aFJ( T>^Jy3;* hwM~+";~_"\3x3M,#1*?1S?0'$U@PhAn=L`^FɊ"nal 6Fx_gnFyD6^X/ DxǒH6i @$ lAk< 2{쬮s,K-pp ?.[Â8 (0 #?Bp/ 'AG'8nFVQ5;ˢl3n\s1?X?1崶Qk2nb&6ZE=u~]K?C6yl#[FVjs9Vtl/d1-D3! F2ߎjiڪnm#"WE1kAX <JE{mWٞ(zѶ(\*Ⱦy5( 3Jzw zv3%ya6svc]p` vK` 4)ǩGG6R1{F~H0n-s[44VbK1LTj {Du@\9gC6ƢwfWR ;{*S:~֟\°tN+:iL ѐi9i<7K=E\}?W&KCd9;NO)* uiK8l5~WV ;.AxJ Ņ#oWH~DXvc`;yX G>G [[һ+g h}%Rhq,";uuQ~qU`n] {F ʪ[.|n?x@ zHOɲ{h[-DxSZF?J^i{^MH'avŒ>HÍn/n)B2"vŢa)8F9!r*ƕ0?^慩w* Cocv Vr!x/!ӕ1cPV)it7l- svndU%@G7Z腱^Mg̦1={rF,O0ʄl._)}=v~<37>gvN2#+v&T ~\~A {3sD=j-oԪ691xk+3'v!$<$Rcrlў9UN"x=GP=ʏB?@U AUxAsqLi>] ̯_U_=?ûoëepVucѾ")0MgOڿzq:(Qr3Y`]ә<|y}6)D)ۢw>Ǣ5kTqqDC5N2!w<̯?0vr&Y7g [}8ϷBMV|=jel~bZUB?*=lnҵ_GzJċ%|2y-q w_ s]*g-T'-Mki/y['ė>ćJ ޹xE ul2c'v-ݵJk^Vxaeͦڑߝڧ玬ЅpD; % BӝKBN;UbʬS+G:=h}K +k#~j12[Xܺ<38~@]unJ_:~_i4î݆6#mv:,+r.ÚGƑ.21~wYGv"4R\7=4+Ho{AdgNo\i|J})w"Sū-䰏,ς wr^|'^W߰&aћ/ߌ'3l<#q偳"iH;mr^}F"MK떶1W:˽0)%RӖ3l4mzN~$]~OKWVz󨹇]t$ۮ- uf.%}#}Sί_.'%-b3xMV̓'NUU.Ӹ c[>lh[[(J _bN.fdwKo0|K<E W'Y_ }Kd[wd`ÂB/\4㖣Z0n:²dqLH2#21v |OoՄXڡ\h VCjK#mq_Y^2m̼%r& EM2:2͏#uS.WShwKBfY;;Uo_¦?aX]K|whiQWN`ѯ?w|FeA!,M bq˪(ٿ_ؐ sLDKXByo3Drq>؟P<~3þ$Z{e{DW|'ګkg`Z cq$YvmN$D%w1q"icunܟak[<xԔͲcf[DH7+oK0(1i`:EH&ȣi/٨H wa63=05H>^SeJx,y".Ώ9xdvXkWZ%>Zaq|`ʪ8c!E(N s;#/fȜ肏+z4`e# Gz[入$kOLOTn*Co"yiQ맕CO^+թ]0ae1ovSYFoNܒ,$Y&TjqOxF"#uWlcI 붽ߘ5]EAMOI~$Ujdq }>aXr'AMҟ"E鬫^sCII. zɑ슼y~Xn1ȉu=C&N`ـ$W (S ٶ^Hv5!1Bs={пk6b,Qws+ޭ wwex}s@<xO>\RP^Z4"gIb! j9=zLsE][(Ganm&o+P>0g9zꪟ]05^>Oҏ@HFfP 1 q*p"RGq3ow?e㙣k3:o¢ޚlVEMSz*\l^Qvt45`쇴zp ϊϷL\Ħ R>:ٺnHpF5 %Y&ܾ?}!XГ(> pCv/M),yBD\ť"! CWu<:WB dۛw,+&!^뻉3rKZ:A"#5e-Hn]AŀK{]DI =~&&-lwO$έAU.I]%FJ]}BlM2^ b '*[sV~U[q=~{ZHYpᖳ7ÄBkY:eG+tȜss͛}Y+@o6vž<"yA[2Z_)v-Bp$3̀a,KeBoFR/)&b9=Kʃbr`C^v68M's=>c㙲#aNA]C9 Q:ʸzs?9x{!HWn ':QbHG6s^b|1>ar;g{Md=^;v]}m󀭸apH$D㰜AR) 'RbϐܞBdlnnwMC1`?Qt0KQ+ śɠJ$gmC?^ kPޟe:owv@/+,U춙Cz.GG hϜ'G)Тw#zߋBᾐlCClQhaM=Z!lEzqCx<(al#'pNI۩qg͠#dz#X/|zտJsY= R<IZ78x#{H2?@/ăeakRO ox60t8 ļB64a k(kHhkոaHtpxzg %` D0!LI=P&k5ġ}wn{*h̖GKO6_Xu{9{\:\34j9F+υ_lέpU5GUg279E^sP4 yWSM_`[R)"kBe[apTy{L/g_3Y,mAg@r,""U-`'l) 'h[e'J qAZ(9JJq}_ߥ ;l|Ft?4 m+|@s-$ֵlw(j̵5!]C3 dx-]noFDU@36z6Z4A8[>6{0oUE_w K>:G|aڂ23sݭ~>R0$*y 5S|/yᎠ~ TM?rW8ꩤAs3fc#P2ށ^y*|$_3En]6Q_HsLµݎk>L%A2ɰ)೸{ x܄5 "˪8Jî4nk."@%k=gRLǷ"WNصo/jU5aw/l9K>`8;Y4&\IE=|| ԨՐ1`9Јv& &:g8簰@=o꬏M{RwT~qo v.Ah\'Ԭ#UlA r]AjZr`-*kWٽOaٻ4X$BdV%d&+ YP9b;p*#3*"qTyW~z ɧ|B:۬Mb p$Vf  논Ķ]11#~丕ߵ2;ŁozmvZ]b # ; 671|Cz!-ÎBQ#SqT4P[Q`Qݛftn",d{XzGY@;"kWߧu({ҹw+ wxm%uCxp]ԐN:}<\s7ںiL6Դ;gI`\j|$vnLg@(aRBlhUNS&I CdcqKλmDCN&cG9W0ℽt?X/T6wW*Ij^(eUTF-CGGFf0DE7^H`+ym弟BK0۔F9P}cw/4EW+iw6lA;ObLjYޟ/$afo'eH'n* ]m7[Gx-$P38c[FAPTYo^'a6{1/NnNSn!<u0A3Z[R:^ĜZDM{s / ]o(d%/;uRwX8`ꁔKD![jЃOnZ$6ݪؽ /pC|O)YǗ/jC_^E4 iܮwyeâ2>r}9UI{Vi4=4]Ў[(j%Gj|*lqY[mX,#AK9zt958$)wpf%<[MFxB(⍄y"{ t$%S˒Rdw'O*4v/n}d&Z9aw,Ef{~ZjZe]SeB"\3EVfrs) ͲDiSJ<۶Rwz !_e3H>9`ae6EZټ{gsK$I<@47><Х.gAs*%#g{eXN; ɩ_T]Xqʏ|η#Njߪ7R6t̰Whz*;la *HGtu័:ih8~S["uZLY5a:Hw}eS7LoJE |(E}3>Ɖnn}wK3S;Qdb28yCjnD "q'/<ѪWK yU+mTZ),p^%`3BS >DP^{K&T buž|Fop/DX g|cm_ý8u<BG܎zM*ukgQw[~y8$ =յ7s sliv*op/D͌ie Ȫ YH̠m+ZΆ؃TH|=?99˙zUAwyτJkwD/#ܼ!eo =mԭt/ PȥdLDe凢s$edhpж~mO쐶(*I@z!5:k+Ko1%ӪzAv;ػeS|/po. dPl標ۥqR; CBZd$DNqsyn5cqq(K҄0>~K]AY0j ܤAzw+zM=~ s#o'0͛<Ճ؛ M4ڢ9dZ ;^^XeEl߃Fr"V3KfѴ!gli ( 2ρN#`^"A^6Ǥ6g?^g=UsgS?q DG+Z!/ֵU zaz۲Mѽvs jrb7t^QB޳3qI4ޱxԳn96Pxw03b 29:{Om ŖezMdwfLl#FF)c"e9$$H!2_07 ܴ#_%݋e7p/{xKvV;KFuKT`SYҰ;*/k/  AC!h!4ozuy0G{-PN DFӄ.a`˱&;E!{eA5 mekeL5v(K{T%6|ZS7# buG?V.7b4* e*/$ry,pXTsg V Y$x1u;&))!,6N5HM"6#8 ^#N򮆁n׾w6/$k-;ިﺷj|# a0|+2{;\+r_Vَ-)ЊJ4bW+ xuAr0A'S0spΜ]ec 4!A?3"6i(O46jL9,{n?>F|!Ijկ3ŊQǫ*a =oоx+߾۱) !u>}P20P #0K>y2b3so?@dK{e 06qK{asSQ]J~`\`pWNUA0m*wď?8[vr@l!1 )QZG"NPxdTunJ0_ 3 .g(! `Ti BGIL鄵8ފ8+!:U@N}o_]ZqRBcqF[rĺxo:~6|6)K ڢZ*Oh u"yƍ-wg"f+vN>zK"2pL ه13RDzbar%&IvP4? ]5F\1X]ťA0Ajv{!Sk;?%CnjM@A]M|; KO Q<P \H#Y 2rQ ``BLERw) )\sVzafڜ\elG^S>0"&NxjQxyX0 <'Pud|L.I%+ oo`/z;ߣ=' &&YADHG/ޯg;,f= ߼Iu\7|P38,F K»+논aEE55i(Mވv-}Ͳ61~yn2\]05bt󀄼`ҞrwCBGV@Ȩދxl?F>gy6a G|4FaGJ<M|Q5=CC[mb2E%7jKBE .ߏ ~C8~Bh;kRكBgX;^/  qI0T^8(K`v0ҙ (0J܈=Z+S։ O`>$v ,}ڳ|勄# VcxP\oiX)r➛EO.`:jiC2 >W[UfNApnsdQꟂL[vʩTFzL䪉1({C(X(E~L~nLCSܮkbvrHe,P~B0p-Ӯ{Dk{R1~C,$ E$n>@g;B0SS"Uϙv)?wQi7X69]Cg&fcƼJ}ъ/WÙ8sRϭ#{TrdfYxƩpxW]X |Hi t>Y0}4>iG@wɈ\P 3 4jfc~}B#/`g_5_m[o$D»UeV&wTW2|Ʈ$~]7a<;X 8FN3Gֽd2}7iv+<zEp_V\M͒q}sf"2LT_#:`-;9a2 :?$3U|A`u]ހ^n5&R}~؂LawH/gGiwp+Vwy?zvh ^m!¦]Eyl9kxZHQ ֞8[ФV2nc^BIRɀZ>Ќn &in}~;I͆?Ņ.TTZS`{6ۊ`SިEu+'zw 4`НF ZOBZ5Uinaҍ!Q(s6~wx Ǹ >z40?ky} Q{׺~ m!A+,kA*0;Bt؟lnOU>o-գ>NCFAh0ht.6,!Sl[>0_6bvk >.FRUdf0i{ր.k0tUf]7Ҏ݋G3:WXi@+?}!۳(wU(- jJ$)+Q:g_zѡԍNn:BXvi,0#pi9 $ kj fn* @[t&?C-:] =A~l{F9rYfY|nwU9ǿ{!RX257@Xuu70(ٖɳۃWM^G>[&-{\@q)0Z ;#vtxۃq'/S!Aj(i >9sAL#UF&Hk{!H$,PЧi.C h8E2 1!l?uPk0Wݧ FEa#{?_L V P#w-:*2Pq%WCnϐhLma|NR¾s<݉ʯꚵz6_J]{!2t<^>`,KB;榘||?T02{^svpe(6~!Idfx3d:{o`/ҞMCDe 'VZݯ:[!7r 0 S |,gBanGq+i", +Ur?z!lR%Zde)ʺiC |?6 u(㛱Hc n}uj,TeЙHmS"R(m\||!W Ppr• `;?A;G`=TDioA=Ai7~~,(ŏ.7c0ape]ySDV'y u 3 4h40ix`M(6BYSLjSj_efK2*pj8r=itSt?|'C/,xS@&JWIbWZ^7Jbd`p&{}#})c6}⩃ܽG4<-x:-r}xB(ęfL\Ϡ5rVn~q.9wh+G? 5&KsgU>k8B`B6}̩1z$?=K;vlڎ[gdB: ]!+[6mV >"?B4hCNVMNƱ 2OWȅ>??F/>.y]Sw}O R]jkQXZ.]܆;b 3Ҷ~:&xT+tڃ,i~x/0_gg`L^|;8pV;)n^!sMϯ>}BZGk:Vwb6#ئ`7W ceLg3LvzG-9jLV-H^ȭtqB ̞-F?vQn>Юt)4s[2yLH>w,jPQUlr -Tf>Q=Qk釯|'pTT @+nvOO Q _[G~I&D}i<0.ԕ}Fn4/K wIϪ Dҫ4p$9g%= vU«dRbNc{3Y"jAv/EPBo)p\[ID)oǘcKB~HVhW^p'?Q>̚,J =/_˚_BhVDHjRs (h@#VVs5m^m4CM`H#v!69OhocP^a1!ͦX韅PChg ]`Dx@|dp!p !c]آ{wϢ]/X~{,OXbcz%V3l_CH{t" `{V.w?bpѢRTGO{FtVy&EԶdsRmxh8fpx* VTL$JN`GRRX;d[]kێ 9v}cT(60\u$݉}}('0;tuq2.sfW7i4r%jUK +AphSٿ4|i["1|Po~bps`&6cIfA4v~DX/ &)CF 3hmdt;Yܳ_gG~-=޷ tXz Ԗv2?`YE1XF( ]D=4%H$&bG"iB@lY2Y=o"NAQp $,,뛀Bb&J5h(j!;XCipd]&5v5 ?١ФFmN(7ӧ&fr#Dv@2g:ho"Il[i+Kb6:MQ}bQs$.AJՍ+C u3č۳ΏK4:3cQp Qc!uF6>zw:(XG.ox 6S WDȁ}r'8f T\8K0!YpzCko\;=V{teBlJ.z퀻@ 7mSP c+"9xlCd0c;N. C.HtJm]1j;?V#4sPl{<S̟.UOX:/K.gywPbM;q% NzO^rW"Dq) »Kp`cXa8ʧ< oH \dp;(!_<=. ޠO[Zkz~BhOL)mbK}}- Kq ûW_s/p܀#Yp:8J xΈװv.M^>0BSemdymkr2:0|π32;CxHJڗls3c3\`-nWN/h-y ^t|zh%Uaoƿ7H">J6”` r(9?bfs੤3mE4Zsn,(m\ʙu=VDDʭ{\ Q}r&Eyx\L(> _M5yТG{sȨBڳbeib;›Z}?ɜ66o8O\(6ٓ}l*qd8q {!+Cl>/0Qc轏SްBy^EH=oCsu#xX#@ 8 9 $1s9Fs!􏅔`ڙۼ8zͥ\@uZ5eA&Ɠna3BD˧F }mrYMXP`2ZhxZU咉(rF d?ʙ/v%]H`ַkt>"HKBJ J%A #$m2%:gsW]RE5t m:jޑNKBqqx܉gw莡 5#BGfQ iu@/$@CK1پ#/ )gop}p!NӁ M0=N®hhq9l1o$=Snjfۙ邉 1;+CVnZpsPܟeG~lГqtE_ՂSP޼%)phsO\Lb6"@q9pYRD5v Z9&0vysSJ6 ˂HwC rGe]ė~gŊ؆ vآAFݥ{™Y0i*%sAI(΍<[zEa-úz 냢1{y/Ĵot`_2Izn]2߉XtZY—Bw]<^4WCZ";6[h* cYrkPIg8~I%-ZIw{bƉJ_€C#]UuwY\Cj]qӽHP훜@Hx՛~_[/||qK?W>9~p;O4/x_|OJ a0 #oQ4Joq~0`Y#zr+ECPV;z bѪڮCɫ ! LBhxt0u!>@t3!!0fJ۱;)hjmaw q2?Al>z}7MOab3MO܂ }TE\ۅ_>4ꦬ‹z(6mNd$|8YzјO,horӿxĸo{7$i4' kvS%r` W N:KavOtOEWTEGyi -C d*hQ3|SddW%=77=%f܆W_JIwlC0ϥ4bla~qYCFɔ^ݛ@dblVP] wE룯uLI[~&7tRlA.BU+Qw 3Mg~1^= -&baI-CQ(tl-O5Z ٥tZ yꮫM՝&$*bA׼3i`f~艓mH!%S)U lGFVVXZ8P,<ܨ Ò!2e3maOȃcOA h#zpH]`3 :4-q#eEOD9?ݝZ`L0$x|aON&M1 ͦImR칐5hHI4L ֞Uvz{]tme[l-JJ6[U  Rh y[m ko6˩.Ub_EZn z1Ҏ{%#{ʃ:i3gN\BϵE{oL{*/֜qLh&6 UŴrv7 w1&!rH-P|/"hַ<XLZ]^{L=hج6ȴf 26Kh2SR twu `()]V=0(:7lҜ"zBл$ՂDIE=,nNyVa=?G!^ВVa&14L~&>.K-rϧ2(xCkW2.>FV(JwƎ~&?B7 51մ:*G(Wj"va'xNu "Fq|i."t ŗj͘:+z3 vxV`˗t7q+Z D rgF@,Ǿ9"\Jձf>!T>n乃t')IKH=Rb|u?_~7TsHq;YS'_Bck`\IGS8^\5=KsMY[1(WVVQ08/]ԡ'G+ۻoɗ! L*"׎@B9xx^v$dj:{8qs i_z)to{;oM-Y#=N]L_KIwr'v]ĎY\73dc3ڠ9^ekO2s)fPiև~Y-Ρ[In("fE.[)asZU9.WL##b6x)ߝUŊ&ogdWkN"=ݭ5tUlʒ"T?#n _xYmo, _D8nq)lǵa$+reBvI>>3(Y/hE.3L)/FuKc+{ҩr}3aa:07U5UUI׮ttYsqqWzf>*i>g~4Ts/])m]:1?>.Tr2qI iwP\]Æ:CרV lHww&JJ(lX?]JMxj߱`:C+j/C gɧ*-&F!?՘s Կv$m{HҺ5$P_VVqRP[(mnu=([uJYi *Tvx[% ȿH]%r'RSU*KZ" (s,9$)i5PE*Ƈ7~K*˪@B{ncH$MSݕ"{rrAEl. M]x,$R6%wgkDbLxVgt?qrV8"M4!:8Pɛ,0 u6)3xWUCK 6*k)!g9 <́Go"f <[kJ2AY̷C6Ҩm;ruP^π\HX!bƭ̀{7"HSTBۀ_jes>q1q-NhO4pD+7QrZE U,gb]ό"-`0Т_ghNSr 11.$5yϾ{wؠǖhjD5ܨ,|w` )`lK5/ڣUSS[ 'RtXSsQP4*iGT8KxCxv]22hN|{QY4vؒZ#'NSP+jSb*y}Ǘxͫ{;|g0E,-c%әw{&6^֦rILN1U5mNTRBQ5;Q72=& u&bv_5҇dv5z Xa+Qkv ZxTmIQc4X5k=59α^ ż/@ ]o@CE[s:]f1j 5~M>sF_(2俠ɓ4y&Yhd~kD1(ӏ'\p^`{N/Ii٠od³|6Ig,'}9`fUҾ_M‹0UVNŭ3XC;U=J ?ä5W;Ej=Ov*$Nmo i 3 SD۞6ٲ0ڊ\inYC8ɎkBtβىICD_ Re_ ´حw8 w 9wzߣ@UP"O%yQ ۂ)BItleVc>v1y y8iBW NT?}pbж Z܅ltmcAzLʡpB ұyNxXn->Ŕ@cQ T/8""##55ȪW>>aߙ oc7Ź9sXTz^)Rq.R>~ I*WV,_C 5Y+Uj'czt#|?VZ׋(7U^Y'[R@hy ;< УbCO5ab7^Tq*e5fEVW񖵌˂vwRQg SnI8Bdǹ&.+kآxL6~./11x)VW:F cF`S7$A-K gH+O١ lLBoWbp`2Jd$ $'83zKS ֑Fޫ,>˭cW[|%UrZ^SڈSR9e䒠dtD6aC ~ $b#(?ؚkfpbxf5bK(NٳO^KjKӿ<8͘ wT8ANB&ɷgqUdy)ʉc"ߗ ōZrnxR38ԩlid!4R/w|JsW y䐠3LBv`aSGiJJ$s@"8t5"3qHQDvcک"'5 NIf86qhzHjlРH:e+#I)r .bS"h\2fn 1!oӞ2 i3Ȝ)ӿSo@}/$x1$Γ\LIȑPQqu6ժIt{ɷYf_4^"RzRm^t!^}@Ÿn(F$Zh[(Qqbq^ IƾK#}zhҘmzS7;h^+Mmz%pCA8Yԁ^wnf0<2m13TpmJ2k*@@?[7{ #6 |_q- :yݴ t J iZ*&E`3iR# ME"WNW<1 PuRskOJ ']:›Swg$gYtv -| l[@AsVvǔ/2񒠈/rϠv{v2lxcEQ.-刉]z@kHY1v1#]S ~zkEy=X@w lc-[D}+xbPpFKQ|[dmޣ{ L lq@3j =]F85fP >@tj-Gs0fK>( (HIk_+OM6mc5}I-^if͜85p:y MּA\@ 0/=*-HR%,NuD_:9dw{h9,?枻G7/B͈ebu5$õq~ءMxp̬7e[nd?n?R`skC{NO7^\{Cf5tjF9WUG(o9J5;#"uJT\?ȸz#t2Pkx;ۊ0[Q"Hh^,q/%0m_t#*8Git/~W07f۴h :o4 M!S?wzjrL5ek" ta1k?+eGM^zxXn-?Ŭ6TVIS,8E&NjyɢȑE23C˪aEOs'E%̽wǹNB2^^֕* ~}\81)ýi{dWWbhMVWc\_}H޷:)x| $+jUjYYUAP ?͕.ZO?5~^+*B|6#Lm{: TP+ >Il X1U5m]j]O"rWZ<Iꋍ\WUMJLlx&%T˥8]>W\X{VS+Z+uA-mUD!:)U-۪THyԀIa%q:@(ZS[Y5c;(ҍվ.ϿW YY|YtpF|R3į:T\SC^ bp/yWlMwrG;1Fj*k'"Xy8*jl1V7*Q &qu9KDjBjպj qv;vs1itmZ, siLntfE ה:٪-<~u±0 Q>qeKpA+4{ U9/fuk^,> F2!f89+,\j3X~Pk9zA&fo ը;ņrqm؀[u0Q ^'NV~YlFBY.%[Plj+qjnny>-*"ƴqr:v99RHQ8I:At(Zld 5} eRdY)ͽPP )h U2;FքURmz{q(t >{ uq.R߇O1)Uᮝh0[7)_ *FTPɣT#QMFzޥC&2K!agw;j2tzm~|W܉Ҙ9' ebn*hڤk q>jR"s:JǤ%Y?tM 4"T[pqA02 "![Bى2ytN?뢓i)n:#1 1Hf8z,H`7[@.Q)g8D$`l,#ԓIo`BG`+FEMDp䉃FTHЈ V?^cS PB' g.* g%'@V~ӲX]~3V &h"(yNQxh*5"GrmŢ_l9X uQ: ĒưAD;n:2GڠI<`~ sY^l`j4_h/R@D5Y+@%Q>{|H!LIos n,[Id5rED0Ts9 6#a9d}oЎK$]Ȝw:i]kGKHo n@ xNŠ;hyU,=xSMո5`Q@(ɴ% TxTbV-V3ĩB_uwk BlCN߁s?W!6N)2ײ-΃ٝ7ܩH4)ʁ΁eFΩ#&~%P럇{1u("TaZ_&, + /A|KҀu#A&Q_,gAa $1' ̟^b/PP44uÒ}j-mP%`^<Z<4|/zPDWejV'}cvZ.l,yҗ0N#=2n)MYrk8zN?P|-$,t "]m%_D<Ţ<K"J^ 0hɜB[«8)!`zVA7-p! 4YTcc@qi*Vg]D92HV=88ia^D0@_@?Å'c똟GjBbMhR:ٞ3 ύ{ބ#k9~'4Vm3$31>ܺ}U2U"IҷoģI383+jLIX4Ѣ>gl)+s^SKYϐógC`QjЄ_ rgjERۋ9JmNEá-Fhe~#0^X<lQ)?5-HX㪽o ~e m-=PSY2)Q%. {=0a 9VGgkE]WZ]/:F,L4j&XWJ#J (WL=8ӿc%W7C8pDNW NP|&螤;9&#= tYJ`'F%@#},Ԇkp룣1J #,j: !l(<:9Q ఩oIw5N*+r]؇$!5&lh!߫tr@epr7e`_M?<BmaQ0d %.מl2tTkt,fݷf נ p!~] `Lm"/x)P%D=‘x =ٯN8~$@kw6'ɻ`(h AVn(B(~* ~sv1I"I3XMf;Ht,䆖 yfұxXnl=ń@\2iߵ(ZsKXI0kr%&wR`C $]RlNz"/n%+1P\FyYB8 JuVLKKzF(iV[5+#1,JES0F}8:*/$\B!g"]E_p$Ż`梒 4րP2Wy) H>iSp5\3jM*O٤sYddWggC8;^96vޱ Z` oTEc G/Fټ$-ʾrS{N,7Đ*;ʸհW6V\?cuVY6@Q.O+G;QDKu}lmhg\ϳS) R혦C&45*/j|Ob$;y"V!R @]u"ѴQ0; `-mS+;-Kq%]bCoj9ҷ[o kE:9ka4 _ffv IR2*ײ?¬f֍͕41WG-K@]TG'ݱ34w % ẋ^(_LnKCFu 9Rչs"aw]>"Υy$ ,\#au',LU9C>'hfEoTNXg ~6䘸a( H<бH8?C!9u?DIS4zX*rQLJ,7|>S(mṰ"cL *a2c61K.'LP `> (AO*R eX߭/dy. @&BZ.23U8)֑;Įz+Er+]O^b*+mS^$P4{4Jq,'ҥE^$#QmwT`3J PNc7Nyb )$ (iO rgw@Zmz@̹9μٸu3rtnx}2؊4`~9x#4kR5Սʺf(]idmÎl{pmޚ_wNd̶ARNESXOڢi;+ooʆm^պ'0g=~ǘP~=x$6K Wn! mD^#"dol{~bQi6uz]tEN,u!jZ:>R"tNPZ!8M`L{ O]8_W0u `[QT&[D&[4k/w]j*hcb<~z;IvP8f&LnEᅇx=9F'?~ Q_(qHb!<&I"vLId,RX/8g!EپGӹOD[N~Æ2в/o}>x|NU͞rz3hd#+p S }}4~ѯޭo]'ھ[oQ*ïη}6YS}W%Nzk#`K_eaGR9?c OSx[koF,)rHNHl&;AB#5E$eYpɞsgHYcH`s}.3&nud'u;"ө:b?ΆqΆY6~a,nv>>kt, gA%Ǿ8_s/S?ئ-IhW9waN]2@ދqpNpv6RJ9~N݉g{w<|sgFa{nxჟpoL=i~1Ddz#Ǔz ƊnWEAmtS7s5֏6`/EYo-Uۍ{j/>^&,P>,<~~@yp\mSlgdfK1]}X9ѥ>*hyx_| ʏʩHzwUҥ!8QcX(eN=wT%NR7,I4`_S}eA381K16ėzwZϠa+`B]:DɾKv%fB+>(1TDg$9ʹ݊nWVW;t(J8W <e aǵ&n 䠚.GX2z 1C=el Hϗ棊%To|Wz Î@cpoOl&2+O c:!O.:H#4E*mھ3d,ko [6[a=n+gUY} W5N! Nl>PhT i=ép,?wr,܅:s_NXkWy< } ISbn19`G΅l`:R _Lec(ׇnEu3m6}1)RN:=zŒh?Ϸ0+Jptۤݨ wpIU_Ʈ4'$Qgэ^pq?Xek|k߷fn{m2o"Xݸ'z2 1G%_ Y^1mQ:X\qfRwuYW)KDz8}n4%F `o!#J$_Cޛ!}VN}{s۳jO-+)v*c5{Ż|t;5'FT߭"=>W/g\޻Ҫc|;(pNn JcvM%^0U yF~oOoJ'󗼿8߉GzF5ǞFt8PE4l^Z4:T 3Z#xcëY."nMi/C{7Zt;̄p'b>xf[=;a E~z"|7c7{>ֻ֗.!(-Gm(6E ^ v;SwOǣљ=o )cFU=7Ptjذ0Ͼڔ'K 9eci<ȗ¦M=ՁbV|UY6U3|߰ 1W%\msב̠bY w3q rfQ冐̭e^; cR,^>}^206Mu;A4D<{5Kt m2R?.Ju4,S*gיKJ- `s$LsN˹dcjv^ِ)n% V%N 6Bfik~"ܮWd,Gpۗ:҆3Ps*j Ͻ-.iZv%zx.s6aokX pk`>͙Ru1F~j,+/PIz@ G0NE^.:\h̪EuzsQvx.aW*#M5 X*Ѱٷi]//E@{?SWb^sW&gg[su ;V!9yT~1paC_eH%oe8^+s\ ~8E߯Y:I P2&x~85=kyͪJ'o -q$'8- ecsmSGԺR(T mF*DUݩH 0Ec$"/q58W+omi.Lr [ @Rd$@C]腂8#X&~%VWhc#`ç0F6\W)31ĥ1y3z70Cbĕ Q/w: Y;TNA (4!8lkQBNJ˼GUQc2`G:2 ˼e8\I704ǐ:fBw.q"V)0,7oPX0o%Z-_4O&/KU umT*4pmx&I>D3JƃqpS,Q2r\ \'#Ƿ=A2ZJ$RaAJjEˆz vV#3'aF\RI^)l)*yÎ԰VqYyQ̓[-+>*L(`GC#\uX[& FG;ks_R82ʜɊB_U4Sua9i'^,m*忸-8>zl􀥂b0奢ʘ_9Ms#?~Re1K@*Htր(.lĀzY4IC N]Cr(EKEBzJrWUYQWV$xlmGHu9sGD{_" cK,6 n_Դa8ϬZpX`?nw!SƔdX 7[9Ȫ-=+K7rf$#6o||WW直rKe^Ϛ8;cG hwґb%QZ]4v, M/Kx*100755 healthcheck.sh}Rh<,viO=<_x#!/bin/sh # healthcheck.sh -- Check explorer health and report per-chain block counts # # Usage: ./scripts/healthcheck.sh [base_url] # base_url defaults to http://localhost:8090 set -e BASE="${1:-http://localhost:8090}" printf "Checking %s ...\n\n" "$BASE" # Health endpoint printf "%-20s " "/health" status=$(curl -s -o /dev/null -w "%{http_code}" "$BASE/health" 2>/dev/null) || status="unreachable" if [ "$status" = "200" ]; then printf "OK (200)\n" else printf "FAIL (%s)\n" "$status" exit 1 fi # Stats endpoint printf "%-20s " "/v1/explorer/stats" stats=$(curl -sf "$BASE/v1/explorer/stats" 2>/dev/null) || stats="" if [ -z "$stats" ]; then printf "FAIL (no response)\n" exit 1 fi printf "OK\n\n" # Parse per-chain block counts from stats JSON # Expected format: {"chains":[{"name":"...","chain_id":...,"block_count":...},...]} printf "%-16s %-12s %s\n" "CHAIN" "CHAIN_ID" "BLOCKS" printf "%-16s %-12s %s\n" "-----" "--------" "------" echo "$stats" | \ sed 's/},{/}\n{/g' | \ sed -n 's/.*"name":"\([^"]*\)".*"chain_id":\([0-9]*\).*"block_count":\([0-9]*\).*/\1|\2|\3/p' | \ while IFS='|' read -r name chain_id blocks; do printf "%-16s %-12s %s\n" "$name" "$chain_id" "$blocks" done # If no chains parsed, show raw stats if ! echo "$stats" | grep -q '"name"'; then printf "(single chain mode)\n" block_count=$(echo "$stats" | sed -n 's/.*"block_count":\([0-9]*\).*/\1/p') printf "%-16s %-12s %s\n" "default" "-" "${block_count:-unknown}" fi printf "\nDone.\n" "!xn100644 icon.svg^p`98(=0100644 index.htmlO;@6w4L100644 logo.svgÞ6 ѕ_|n%ʸ,( xY 2.xc Explorer
Loading explorer…
P{p۳x Explorer iQL x[rGMF!$efUH{vV0]UYYYyg|tGZM\?4Sը=7un7:u8=\+:VݿVoU4T?+A73j;щ@}:?%J_O(4DEajOtHkO]}x{tw8nO hS55):MH'6' -*MW덚h]q4"8 X CZ٨wHtYzxhF4bl T멾Yi 4%|d^G!*x BFռټIltk3Epc+S1ɧcfL9-uDw4Mcm', hό6!0qy8YB,΁OU8ꦶF" #Eejkɔs ;A 쿭ݲYe;Xĵ<fK4n-:RNmE* ̛Y5$jnQZ uc[sVVrMuH@݈B 0^ļ)mtLfb^Z\mL0)D'ow$4K $&M ("ĝk@\ n삟Oy+:2 >^ {$AR Z{FR&gݝsYT C(&]"9]Vy5.1řdNhW5Ra`^C-Q  ?WIJ M v[[#;Cӭq<7 Ah:sn? }>oCl:~^l۩?'_ME?KdǠ$w^OCȕ#Ch:=vi/E4Ep `V+ahPmb"Ǥ#ppw8f5ɮ1#+ZZ ô; X^:g4d!:b.S_ sÈ_n^m=ETf~v@ $ rB,83z A/L5 =I4EržLƺgl-9IQMȬe0pI 'Xi" p 6 cXԵ&,gp;Eﺁ[4R̢y]gM5V7z`= w>(-ʥ5{=;)-9뷰5rtե5g\X6zkk.AٳM#+.\¦W]} r6&ϭ KmUwWdzД4BS>䄭H+@;Fu2)maW`mdgוεx`,+ӋsF$tG6GQɅ[ .bN z/EUeWR& R\ѹN G$UGcO8<-$VL\",9[aȮ7ӓL7DKW¦Ót ;g8s޳ohnIBl8yt$!/iЁw|@4^Ϛl\UwPf)p'S m]X`O(p"VR3#HکOȁO8Ƿ&bh/(+]>܌=u8h@ ΰ:ua f )2Q6 ns{ _}2q]opQ.bYa}7[gvX s{ vMdb}>wG\9sM(ny 2u=F.fucx$yR#6si#R''KY)Un?Λ$)_jrcm @noXЅ=Pec|k;fz`N?ϚcE96p:y360ȽF* ,KRl(8d W xI@AW65n`d =97OD!ix4c`M>A Mޠve&tR;M8E@8:r)#;at_w{̬G&swcqQLJ'{(➇Ed~ -› ..Ǧۭڤ[#`DJMS:o2ѩOѫ}dѰ f UˢKb)λ&)N^f%?P@ k a4lJS^,5I]F0h(֥^C[ .9NR;5, 2YA8ݙ+eѺΟ/|RF'2;b ب#Z_O ߽,7ݡϐ `,63}I?e'8ـ]hq9׽z\NԗjW/SZP@dYC1K+xVWxZvKzw~WrDqK3O^eŚ c6v߉p̖%v|-/Wܛ~GTèA~$۟&.2)1$|1Z$k;^#me%|N%SIb> B: k=Ī*yODlvjyـt^JyNh~/o =JKU*)HV<  Wccm`mc$.Qբ[g _%A~XY(E2K[-b^e1ۖ2gO/1w{;gn:f alGq8Nt_ù|,~Y1?nJ涥`E]&P({ȶ()"i1D~jiBǖzc*$1! }/DؖbAJ ) CPnJ#VT2Ӏc2DRLPD%Zz ]AHZ.tՖaZŒr=ɹjRǫVze Ӊ 27?bzhq?iM-9SMXRt. 5'*'~.e҈.e[ўGII5'0)x 7D!Ɣ&$\ ΝN?}@ia53^YY\$;;yL.P:IF~$wDאָS,'F$(Yjy%kV6f=SN,ݲ_"Z+?7U.m?X6(1@:jm&[*y] - RV0J!뗦;kьa͸[W ̐|"dGhM%9ÚF,k"}oQjHM8eZL\OKX;u 5Ir(Rb6hՐCaz!P371jIEʰ\He)yzY[s ˜OLu Iȝ}ezKm~YA=s38P_iQ6mrZZ~Oю@T<߽e8΃% *H`ri'>:IPs['cn-ag &?¨PPqtn@'L.(EEWH},C "mXNZ 0>!x^b#ōRH\*'2 wZV TGx}`@%To^Z+Kh.$_R*pӵ]/@^ u#~;*5`R5eL2m.4t(<kJ~Ø[_zkX4JF?U fQ(RLѹCdu{Vq+V;EÃ`FQ +V"8!sQдV:KhLB3@즶_1TrH@_CWslY7µ;lǙc,;|+=!58'T S}k3I)i2 {`KdO'SxZvFM=E{<&cdɉxȒhƖ=gg}|$hXE)͙''{ ![:Iya1i5 lk+LTe8O:8F6yIɏLqYNA _Mr&>kD{[[nW9;QX0):Ri2(V%*ljQ$O_ͲX*TY8*.)4L&&R}NyQ"U 1jӔIiT>ϔ)B%d"c fI|(IO AU>ՙP*(1.tN"(k,4MBZ9WSki; Qnz2K"^Bݗl@x݊Sڂm2,e[mbOܾ @*YF*Z T<#N/H/3)(jf.TRfJaWv;b,Ɂ4[5喩 X6H.غ-PGg|sOZ/@yo tFmX<~[9(vmciCRӳuM cOp錦 '7\MbOx疭F}cDVaIk4J@`9WH5*RZ!g3NJOmE2 19g[M!zAs"bk`[pE"셝K$Aߧ,h/@J;C;V ~)[ՊBlb 'Y{<:҅LM#&iw~߼PYr)XJۘwX6h@$v UFH[Y0EQ}za8Q OThpriFXׇU>dʧgO}5Xl ' ɇt|: q2&b{PQh.d$U>E wF髳w^o.#8ۂ""I[vL򫮈u~$F0]orY:"U-BE5 su`\98NpmxVRi[EwԷvk0a;?}kӆoe+duXyrӰ<*[1߰-_ȯ CZ~oR3vjջkuZ-bQ^Q^|t?<a=ٵc}o0_dā;@y7mZLoBfa!ĵWi*Vvf1DeqaJăȓ@ۂ?!2X2b`A4iK*b+ȅR;jnY ȕljde<.$V@5lZVew>BPptq篈p$[7g*+lsX4h1'UY?3 >䙾?jz.'gstlʶZ10~` `zBJ ]n ||۲;yb ̸:Q^b1}<~GB>f͟qQ-ުGlIϒ<$V.ރw$,_R/o!6BH`wYp4cEbѵ+X`6N'*Uq#j]%3&gl9n%h"J =Xfld^z[O_UofW+Mޫ4ʺgn(ܢA4aV":L;Q VnJHBy E9)M8 -xAO5g bo.6ǀGP qʛ|)Wc}ZyKqrvK$IE6 -= #wc?]3СcInlAQȻڏlT(23 U[0Ye9;Š c2gE.A }d\9LE'!KRƷ8o=-#Td2"-B &Eƾmu7S.&CǢV7lQ\֕@n%D `d _=,'2pl͸Um0 fӇ~F!Im@v ygkf 4`K卄9 |!̬dTT}?B S^vo ݎX8eãĘ8y{*VAKӃענesË@_{ʙe'W-| l~M#QStJF>_: Qoc<3BugX4jaݳ졲[Lf"!_e5~i2aɽt\PshLq3\̑K,B0з ڥ@ЀK5 @>sxCkLsA<]쁞9Y8( 78 a+:*z{"ngv6W$V)3DE+&SMOM[هFaCxI:dF&q90Ewz]OB<d4.so4G G }Ks_=[ vYS9y_e|GݒW[$uB(ABU[d+ǔi0TKd9=Yrn#y~A]<%-CM5b=KRm <^,Kͷez؄ 6ipu&Q`S@:A9 NR(e9 qρbmaDxu#͚Д_"^jxN55(v"Y'v1Oַ(>m$Xv~$v-DSys\L TZ8BՊJDsF)u#`NМ)-@W$  xgUxn^IY_HsպT䈷9Q,w7aWmM9~\VKlcM:FlЩ5K|MGZT颧`PKU4! ȀɄNUi#u,%T^o+n+սvuCy@©\S⣠ pUbC%AFxQPq'*s@ޭM 'EBF"f;By: y?^񪍴:1&")W} ;%ԧ?qH]Kro? sK6w6(tab FǃC$9wtv^CAe8Zš/=Z@*qYZ^D{e]6Zt^T٧xh`ňIlq>(±C vf@ LE LE%\D@u{N,Q1&KsТfm*0wz4zn"N+yOG8Шq -!BaR 4ҷ6Č$[5nyg(¥f">t^݇K^p>@94/HFvRSKTˋ8$cxxL:wav YG=*0ۻbzR g^l[uoQRq)j[irJ5qgIKgrv$q[]-fDt?8Mcq5Cc$Hcޘ/<@S4y>{J_n7t1`}B6B.ꍇmWZ}-L/ YUp9%8kZZ ؠbTE  Avj[f .\[B+ ^t~#lq0$Š6b\Rgdžkw. wxWn6?+ \)-ҥK5YAKKED"Um=ĞpOrqgtǖ9xz'\NG6ŝH w;WE !jRDnspqg傥\i%S^quYrH;^² xT]jIF0/ޏ ^Àfי?fvV3ë .2HPSQJ RZjU,p6EzTTZ#K:ZIxwxNƎ=lr\t٧Hg |&Ůǔ5=\eOz,|$UHz 3m#h 1hGjIeNGtBsw{0dȕ=6Fq|i͸rlHwi%< gv  S=t_3ymf3YtE*Ś}[IAyZ+ 8 9@U3.rA<'ujpegl8' .\ DQxCxfӊ= (>'6lNg ~υT.eu"M =@lw^!-^V<DfaSP\c=0%okyΠP1 *`Αvnf0l5^F&pyR K; w?q4䎘Q'x:I@='~هW߲HK_Fߥ˲AF`cީOd+S9PS[ ]NR)XsAB?*0VrDܓ3n,6[K̒WG G1~(~t4%==94Mhou!HB<*&P$4iAr/$z;tryIrMfo.eSL JΥA_@bb}ZX}xiH"VJ}]vd~'G 79 Y"Vu˶sr50||?WS.||;ʶF15\֌z[0hY]V_C 3Za\V$lWFXxTzL w^xUÂC6#ҟBF06850?R4|ڞHtX^cگa!H?QƷZ\j&ׅ *9%nT mV(Ny v^S/*B|}Up_^|~jmUwWJjpZp;),{Rn0//[:%gUȺ,-ldrUFU-!R ,N*\Ң& ?G5oσxV9;{sAm VfMQl x\rF}& x/9eMMփC!`nyB߰6_眬¥y;1 %++䥲0g$u8WWټ(k7\]N/L:UY}w$'Nfj7-&i]wQ><ɦ)._磌|Gu6K+=:u;nʸrYӬr,uȓtYKU8U:fyYӪPY&erZw/-.0S|c nM:+Er؇/lLkl;7`(6à~(ZI)YLICV3K.{u[z M)%Kh6ǧ;r0HgwO!坍Ӹ>)JBv!|muڸCzx!EzkRŢO{ӅZs$>L]U1Ʉi+yfc5]L>m>Rxօo\e:6=e9-^Ӕr_.r̖○9-4q]+7)gj}5.qJ!WWY (!֭O&I6qGZSjB? KUsQC},aR(lP}ru81ͦ|H#߳sƺsҡ.[vko\lj1&-P]fk#o~1~Y`7FWd8IGXoKXW%vd0hl VM*1ƾ؅V0 %SьǮ:OX텙<܈x ÖK/wiYRm)'Yp$ @?-FlH=~Ӈi6roȧ*3pO:Fk^pA]6_<|ih1e6g%82AFsw0 i?4NXi:]+=oڃC3AM67xJftmËGaU`USV{(U^l E_r7Ĕ^sEC)q/Ag \h)1d#ڀ(=(wD#RJ:Nܻu"tt&~V<V:LBLax mϓ!Ej8G,֏ָi0i\ Ojdޮl/\ݸH->]LI2 Vijz[@Xk H!')[Bd85zo1[IT@tWn,5–;)}.)B$Kdi2 v9d<(BdȠ݃ .ڙRQ@qv!Qܒr% }}m (܁( k4*7|P?¿^!oa;8Rw0Pm/̟ wY۰ߍc3@8o=nAlD'c(rFDhapyO)p`pU(1v~[l;.&ZCA5%ғ4O?JSDybB]-K_2]9<˓9 [<ћpnbY[ cze1wWݾaO@EDM.6XdQc1 An$K1Z3*^RX =a㰓D2Sُb$2f!>AT0=$,ݘ/FS˓5I>%e>X* B)!ҥ#6?\9 ]UxesdL`X/`K=/ Lڼw~.MsQqsaDx1Y .`J!5Z!+|y^ f޽mB`impI׵|{Мڪdc8{0ߎ}I[s.f+Kp%z}j q%19Z!PB#6n^_L`M<-qv%AtFPy ߩM3M@Naֆf؞ܤ?_i= U[l:ID @ [h d]:kPxn .lihЪ 2J-۠k/ЂYFնЅkBx$6iC%;>_AMBׂ(jO6(r3o<42CI><@a,XsTJ ^oMo6l=vvT!u"`NnGlyq9GjjSl#xX9}f!ϋtj,C{ᆡB1"3yK?y/(;D+t4&+ '3#xDsgZ)ƣ=OtT hO(7 >݌7D@Vߪo+,dzZ lBZðzѯf]Eo0IrmJ3="d4sȻ)7E\R)&澎"^ۇ[i^s#5G_0 a `?w/vGx oibG<ŀ #^0:ǎH%t ou0퀪 5 53o>H`+[&/ŷ5Z!LSG@\;mǨf4ɀS)& NpܚB5p N8;X&08֓!Zj28IGJnKbGk S!%9(h&ʑm# }&Z[l԰ .i6 .q)d u&hp1*\t9Օ t$,+k/GLX@dI*1吺RMaz wiAShJ&u0 ޤ>Cxm+pHRc;%mG!d^.QF}ؔb&Mt~`mvY0)fnXru8c?$g0!]{;n/܏}yo~;ܓpl)~鞾UXyaay&p= }X!K-*W+lp[Re0](e^Xw[>+HqgqEQIv6C&rԵyq kZ/\T1F/7xaIX>$tzk 9(2UN] *S7 `D( {Pm>sSJr@z+pz鵒h;v hqA=ZG)\_Dz:5 &+?m~ lOw9"\?,K1BJ34V€AlZ;ߜa{m~'i x=Y 4(!H9Ց%tӹScкT@oHN |\i y#0NJLŃ&` *+g3%Q0 S'@?c0ׯ9 iyo~÷:|28Cb,d~lJN_p_B CES䥘R3 ;aG)6SWƣ#y,"Bz$XiUUl0dX^c5.*Y\y,AWd8Cr\JOaB┥wH*BӝnbCq#4Dy=5z2- ԗM߁g ˓I?E>8FN.>l~3\.k B[3^7=knRC[  h=Z8ߏ/jsBJ'xzVγ߻J#b XS4 9BP!iU=xO L(|gtzO8L>,krKb@(OfVGGs_ֺXpTxFƍaa4VjgFu4iSGc3~a 9FpxJ_[}hW,wstZͳ+H yĽ_}J3 ~4(Te^'h좸 k>D,_x8e5`[;x[(s9zj6 gqY*̽F{I&PqX䞝B ε~i=I^o0U"NQf7g +a{SKޭʕ9/Z@a @eWY2˜d9XH^ FX\ J $)/SFQH࢏W]ѱ<65@>!#fo$==߻58/o<O5,A9e,sVt_8܌@-Ku20*{^1w̨ Wfa٤I aF `#.lŨG42^TW9&`߻vwIHP?Un: jG)ȆUv=#mK 5 |XEoA? \C^E..# a~~wf?I5,PSLɾpGwgQOMYBkI,p.޶m7:Ѡ'R;m%$OM"fR h}XdL ]MOSEI\H`j)Z4Q`4C}-@1O^ᶓ2# U4eb(M#%C\LrޡqK(H\RQUf+~p_.2K,$E)I2p˴4'ȐkR<ٻ SS/7PS ?4m?qC{1yɭsd> Ui2`|[}XaB ܻ?pDhxfqx[ ˔ cg+\ \ߟLII7`ih5*&XK9e5h6G; ^9rN4 >yQ>`4/_eHE)}4H@s8YM[DO GSTXGМMԗш%)>a߈V)X7(D1h% tI2hY>\/R`EK)F, ׺ܨ!Tw@e1BxCu|ur, v]KH,EgO[Щ" 4A8yhεkZ\|=unגnhÅ)9?/󿨵k:prwn%?:gzl]jׇOdoR_ r iP ò2gRsvMn󍎠0ӥsp=밒l"b&p|ltP 4|DVV-DOKdՋWÚ9C 2;nJݐ^3`6أrC.. 8O{۾dU$4rÉ`aB*c[S8w[{hOyMA P 8PfG &fBB5t@|9cvّ9/$&DYZNJj~~e<ĞIB|* bDH&al/7V (<đGо;ş^錎Y.X-ה# KէH.t5Ȫ7A]Uju9yBk `TMMw3Ѱ0eѬؙd*>@*ȅu 5m@1#$еʄDK ]K ZM`:7 ⽓d}l-7<y &faMA=.)@m}bChƼY>.|5_٠]W (nF wDK;S1T&8ʲ*GRq+"Xߋ(|hEЭgh'N?Dx3Oso ]ԑ{i)R*Mݙ8-A' &*i^3x@ʚ>4X+*TK]|4Vl{~<@KC*X"l&ovhW~ >@3ţ*:F؁ݸ6m!AyfPK(DDFt=K5C⼳;mCR șa|J# -І`'^-L$f6 l@07N |Q'ӓ?]"83Ԫ$8ǭP "9sMB_@?V^j ʝd1p]ar߯ql5ŽSl2`'q;TFcqZscu6'fl+28}:]7fu-mi}@LL!vm~a@!s}JEnA"ʅ70 C>-z'zCK"G?f]VGؘ֋SMO4q|D U7z~;u_0$\D|և NAL >zG>}L_{<Ys>6DCB2;glX0kpBԑ+ 8$Ml v'wSf~Di^PE&ݡ}M! "_@]Fqx>m^a1y1}8$Ϟ l^'[/ݵo6V%䤲xb package main import ( "encoding/json" "net/http" "net/http/httptest" "testing" ) // A slug-less /v1/indexer request is answered by the chain the host names. // Pinned to the configured default, api-explore.hanzo.network and // api-explore.zoo.network returned the same window of Lux block heights as // api-explore.lux.network — to the block, on every fetch. func TestIndexerDispatchFollowsTheHost(t *testing.T) { s := NewChainSupervisor(Config{Chains: []ChainConfig{ {Slug: "cchain", Default: true}, {Slug: "hanzo"}, {Slug: "zoo"}, }}) s.SetDefaultSlug("cchain") for _, slug := range []string{"cchain", "hanzo", "zoo"} { slug := slug s.indexerRoutes.Store(slug, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { json.NewEncoder(w).Encode(map[string]string{"served": slug, "path": r.URL.Path}) })) } mux := http.NewServeMux() s.MountRoutes(mux) for _, tc := range []struct{ host, path, want string }{ {"api-explore.lux.network", "/v1/indexer/blocks", "cchain"}, // names none -> default {"api-explore.hanzo.network", "/v1/indexer/blocks", "hanzo"}, {"api-explore.zoo.network", "/v1/indexer/blocks", "zoo"}, {"explore.zoo.ngo", "/v1/indexer/tokens", "zoo"}, // An explicit slug still wins over the host. {"api-explore.hanzo.network", "/v1/indexer/zoo/blocks", "zoo"}, } { req := httptest.NewRequest(http.MethodGet, tc.path, nil) req.Host = tc.host rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) var body map[string]string if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil { t.Fatalf("%s %s: %v -- %s", tc.host, tc.path, err, rec.Body.String()) } if body["served"] != tc.want { t.Errorf("%s %s: served by %q, want %q", tc.host, tc.path, body["served"], tc.want) } } } // A host naming a chain that is not running falls back rather than 404ing — // chains are added and removed at runtime. func TestIndexerDispatchFallsBackWhenTheHostsChainIsDown(t *testing.T) { s := NewChainSupervisor(Config{Chains: []ChainConfig{ {Slug: "cchain", Default: true}, {Slug: "hanzo"}, }}) s.SetDefaultSlug("cchain") s.indexerRoutes.Store("cchain", http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { json.NewEncoder(w).Encode(map[string]string{"served": "cchain"}) })) req := httptest.NewRequest(http.MethodGet, "/v1/indexer/blocks", nil) req.Host = "api-explore.hanzo.network" rec := httptest.NewRecorder() mux := http.NewServeMux() s.MountRoutes(mux) mux.ServeHTTP(rec, req) var body map[string]string json.Unmarshal(rec.Body.Bytes(), &body) if body["served"] != "cchain" { t.Errorf("served by %q, want cchain", body["served"]) } } 1uLxX]s۶}~ʇr;G>d2.DA"*`P#//HN&869gjdK%*XW^Q2%xPun^nLMZsp2ooB F,~tšfӾ"/F":ZzZU3KN8yDWzlKk3ٵA2 $V{RTZȦf-8[{e!`GڳAX kLWG.Kf/3d0ܙ S`ԪbQh7A"+Tr#B,$sĥNeT .~7)țpT}Ke^)a>+xl+`T*cTű SñމaZjvX6uy'(Bx6Ptx6h빲$Xզ (Q-0Hau'(κehXt'5Ga[rǣxTG>,qǮp]#n3DtV[xC̥Tu"&c =}) 9‹TԵBXMW JB8V9Sz  SLK^ A-k 3q]kzWA XMsEbv7̞['j+ޡsX 5Kr֖hxd1i %#QX*ȫ P:y2Jdd(X+Bk)]!x-2б/>}~W@9 {a'8? e1y>oտm9+MHWS7lM/ߛz) LK؇:Ol`6RmԉC˶c3v"C)}rI|:io'DOJTX/Qgr4^,=6Im2KQԁl\G=i'wprP&"#\ư("2Ҡ}l,)7.?8`rhHJznT3cVSF9/fGH dzV(:g 8!%E١@Ao1KDVU`ϫ.=8OӚ-2go-*Hy!Kb~6Tv&*6ڦ S;ը~ CڠP6`e-R i4Ba_Ԛ8익Ʀ4lso[9v>\޼8pqUfJ4&10#8'")%;Α˪6hUJ @-d[zQ?.<䠢<fEvE<@|Q/>7Oݯ O!fQ'?=6v&`1WyQEYEsnŲD!}BC\tұ%*k,gb,, j WT]tpڕ(>CF֧f33b32eWVW`e?EP`=kNM=o٩.VL yDk{:-U=L"c puuNGyy?/WR: #:x|D {_Q2Ȕ$6F⑋Q`@Mh.7EѢe갼}K5DxI0H8/=>Lz]~J6]L $-j!xuUnEU"AQp$:(HINd퀐ޙ3ݛoV\8ZN2_Op@pU!6]իW.!5JQ+_81ZY?ZnŨX:WZEzq}0#rdw4./%AI!&ӰVe_DYƴe|A"MtN:VFkkSieJJ{'~,Nĕ~GBzoov"hRCSOB^#&AlWW2ӄL s.gB<=9IY։:p0:*»Rq:9Q+I}љ{44QJ_[q8y@W7h;qMM$0Pb/:~ Er(:s@h(#vkz8r–J:S1,e.HqR2屴.)Ө<,xUh.)Jd4#i7p6:4:^XhPTJ9 _ YcSCApI!ӺH1oWK׫rr`tLe4L?dmݐn9:}r9K:{v0 PhX:F + ;vqJ⯓,})FcQo%x$[ V)scnkBȖ& &Čy\)@ PIAPemCڄV 7C5PH:m/cH Yx|F:9wY ՙJ~QL!m C!E}*1`8a0Q x{,,ނW G#| p7o%|iy={3z:jH}[ë&2>u?yyt{0tN7Pա"LqXR޽OЕFPU^½foGw0=3b2_EpXh(p PrȌ5\2R˜@ࡡs”(MH ❂;ci|Ja2mA7]`==]gqpǥ¹JeXU3&"67 }Hž6&'4W =inkөAG HҝJy @VPA՘~|4fxkJ٠ժÝeQ( 'Qkˉ;EAO %1p] y?f/ߚoQ)ub5+kgtDWB 0챓h+70~e6_g?-}6kw׎Eg^45GxYnm=ńZuFaYIcYk$Cr(H-}>Is=?$p3|:3~c%2J`:TK ?tYXTz2Iϼ*ҢN#-gA:ۍ'av'D&'*JGɉ(r&8 W'Y5G]wiOtjt\+A\5Q`_A3f;$ΰW^b.#OHMd*S%$9ZgSHDX$*Cz&SwBADlJ*Q \ߞNd* rA8Y8Hʔ9Ynlv閾 Bx*JR=߅4>إGl Fũ^q\ԫU_:`%B`U5zyuޠꣶj gV<ky6)#U}UmT[5Sٹi԰u :f[6l+Qo z9jV;nDzP}!jVkU;T[A\ouN G^٩5 (N,J5t-(i&u'Z$Yt9PFVNnq-1S($HDB̤xdh m XDIwbA^GЦLn4FdW1o5 ]Q3pЃ1 ^8!" K~b?J恎wfcabD@bHnVD&#P:0*}@zKXФld_x7]?ٯ^Aյ c넂U& ;Vv.,SExA" #{gp11 !?M8w_h72rvcu+ j/tkE`/W*-[q_^ıl"A@N>SY2enhюf է4"amsj8Q+DP4x0Z>y&4X2ا g_W|ym`4K"RRmF$ J'W&B^Ѣ bÆgt.m+`J2 C|OrG-oy*D~:2te-ي'-YߕFBt@Py}JeLM󨂣T%*'?/NWJWY藭C-u)2JFTe_) lj `2EQ)J;'8FZLPD, XD : )äMdK89 $ PiaD߰ثߩDc^QIAv@ ]LN`D Z`<'X&xV -Fo}>6Ug,KőwggU,.S3#38|> XojzfOd0 s66D跳O>\ կڭ5V#t Sbz:-sSZ[Y$kջF3wkNz4ZNzAm6[uRED:]+`e@KOHշ7| IZh9֘rvMO~H- HJ:acBX}}|L G|$SX`T_2_eDCDvBn8n[6 #7Y(6Py4B ꥜8FGA(^PATP@aκ_06&kfKJ(9~\T(8JUא.88NC} wqxii&ƺt!ML%tQNE9<X5*Ro&~w %'ElGB S4 YM4٠6ziF܆-@|5^#x95QߝX0hNJk-M9eX+llŕ7 2Wy>Ù|3DEڦpmI!Olx@057|ߵ ϹHk-(@GO`I2?G.*0T SlSkeγ!D0MHtxF k}J$P %Ir0Z@MSAŷt89N4teD_h'+ANL4G)=Vz|9!qzAm+{^w^VF 0V4ݻhVkPMmb}O..xc@ˇ9;[h@\N`jمub~",d̚Q<e%;o 8 cP* jUP`1{1PMw"BHbN_ cF zw P4(0+]LH;ԵinwN`iᾒ[@W:9`|O G>lW顋Gm"*yr,ڬdžbb*a` IjI<x. u@%ieITF kX?˓,%9~, y%@(KΌd;xQk&. !$DEA^KDzG{Wų =qۏ*O*E 7[j2 q%Ϟ=rƙd<ٛy 4ڵd`K\v9D;2j4*|nMm(oWM>{oKiUγ7o\1ӻ%`?YA=G5'Ur(^͔B @ 1B&Thu8d)JC_Hoe9ʢrM4˫Nvc{S4.5SV=^Pk7W+7["J:}–b8[*$TzwxWoc$A"#}ZDT)J[HI(DRࢉj wBzgV{KZ[ܿ@9]d%-`\}Lz«TjJ3&"SN E G 51dlJy҅6KXkJ!5(.BtMK`DoswWA"ST"]N?tb36уnb k6 SK1t{&.PёcEXWu܉|lTlOe#曩~Ϸ&?r^Y͟&gOiyE9}穛s5 o<# _,.rM)ҥUIB!\Zï'=c- j9{{=୯2ߺg.OO<1y֋V7}bYaʨ 풼 \XY2bB*rI26?0XxͅD4'AeL_y ^溝liMbeNB E=jX8CJ!CQ0sTZAZ+H5D>9xFϫ~vRjJ0E̥,7uÄp j1%Ik z*^`qY/e $g-Ϩ8`evrQ?Zuk~& 'N1܈c/;J" 49 Ob;9C/SK{K=SJ"2Oj/$(ҘT[tXT`ۡ$1cw J؎  !wwy'7(&]R4쭰n7.uhHwۇ<BTA;xX5$a໓Kw.0봅vR1f!s{ 'IEӧ L@rU,nGnsɃa9e}Z9Y1}ضEdŨ2"hλRݜ<$k %da%`ؙI=[lTg~l^@$v :"}oCw wy< 9&WE}cNv!|Ήz7,xbr5lxChǃ{0<_Ӵ.ϟFv1 H?c>=8 e-mZ9M (מYa8vUE~sv>uAxMJAEF.VvFH,BDXzvv`w;CC|rϹu~Mޞ./l𰆐YkI c!t oaDE}#! 9+hG9dN奮x~妡f3MB(x +zeMqYG)kY100644 go.sum+ʊX]`93Z100644 main.goZH f82ݖ㫸 w?|P6Hf3K100644 swap.goS,*ٺSʂ&100644 swap_test.go >h[!lfj-|0ax_gnFyD6^X/ Dx,,5 ЯDnxx{< l.g{2xL͞DC /5 h1:8KmHUvioLt+BlMLXeQl1IBqze9TnOUkGQsBBhOcILrHC 5CK l"xnuj/͢bI*tNoxB ll~~͔<axļ|O= T.N}}TTPfBqiRzQbA v, ډne8~7nm Jr,lxq +ms[[:muvI68}ACE:0ʄ100644 go.sumd?V-3rj ,j_GKjd ,gAG*znAg 9fqw~/n?3!N?J@XȁTt_&)28Na %y++S1+! JQ{fwi(3vB6B&`4BaDtkth5Z^ &'Y+̡t0[hU=O+E]2}hdܢ$9O:@d3[kz6%جeb7lШ:DFA끷 v)nvl|h⌞aȳlK"q@lnx^(63<89ԌRx՝0dAnk5x՝0lAnk5gx[4i\ L2 C-r]̋JJr}ˋ<´+R˪ *JrM͓,óS#'OM/J,P(3332,<j^x[4i\ 2 ,< ͽC2|\2Lݍ\-3 "r#" ӍSK rr&OM/J,P(3332,<w?sxk|U%E%N9Vl 'x{>qt CK*Ì:\011H/$,$l^@* jWxC 46u1x0vvt]mA100644 go.sum΅_CNP:џj/RxC 467lg׳+AB100644 go.sum5 0=^@JS? Vj/xVx՝0hAnk5x՝0xAnk5kx[4i\ 2 *C}3], MS<< K+KCK*BM]'OM/J,P(3332,<gkw^x[4i\ 2 ҍ|"rB-K*|MC}]M-- 3<ʴ]#='OM/J,P(3332,<:goxC 46&PɈ˿eXs]Kg]100644 go.sumPU%o:y}b(, j/RxC 46Fn^ekN~r100644 go.sumrU@5vj/4Fnx}3Adv׬f<]fDRfFy'k0N^!99G6xJbl)%Iũ ezP@ ̔z܊sN5d4kh6y"4H@qCo37, "D<&2\ŕy ezF .gqe1g h<9PTx{n QkFrBRx{^gt&#yD6=$ E[xײȲ&|?Oq1I$G7 .ԧ{PKZڱ#*++͗Gen ?Vq^\n~_= ?ʠّ~滭Oȑ8ULt0jÓIy/c ұ3A?'sɭ0 {.Leآ93( Ɵ/ Qq z[(ץt[]iոpCΥ,xSY.u(XE1/f ^\D_[4z[4uɤjlif/Uʪh>iZ[Vd]xHWpM8px#b !Y_ò6˰d#y}@4+;t'N2cmcWi+lOVΙXLbbxppAq'n76汓W{I?KP OgT Q5~Kk}$[۳[{1je$Y.?qۣJQԒ<:p?5\+5A.7åF]@$qbPDoͱYq|?ꔶꕺ |k۶)Fj?{d- u|LGE_2$Jxu}y j׵S:霗k`10ؖ N8M׌ty26V%zIrӖ9~oMASʻ-O!nV+BEoi!LdE쫧F".p-Ξ}MLKw:| xoo$8{T1&驀$~Xf1HH-,ע{CE)Ż2FysWn?bخ7صq흪E].njJ4ޞ4q]S}߫&ըJ_?ފb(<ӭa&wO3̽2(۷ͽy;:,! qBYZ,ѫrWq%؇s>`ިq:򍞲GbY'#C>gɾglѕGq]Ln$ۨs^F}*,{ƠePӜZKP~Qg$# (7¼מd#uP޴gm{t wv9Kѫ*'Ψ%Bdi]ЂDw^_1Ǐ}1h+wܚiO$QYOVXRqՇgMCY4-Z0wm޲^L 1|)ڲpJla b&qP=gÏGasP~ym?IqJy\| WsDtŦj=mu\J?)~S3!N!?F0$O6\|K*92UrDž>GϯK-?7?njJ3eJ\Kt6jnJ [=K[Q߹oyh6vɞҥ7Os0P!(VEz~8_r[8l/a+ph\lۃ?]`ez[ 룗U{-ͱ;)NÀqun_3̚-u]q,fb T|zy%zή^|*v"eumኸrvˏQ:IFB&g]G8n҇td6@ O&Z^7 x*<%h0Pe1^/wk)Cz[XpZ2E0ٕQ#߯FSFn]6e~]M2D\_`ks%j\k|-o\*)|ð,{g]Х^Fn3[`'FhGiG_)p$C`_f1ø4KLOt*..(NXKq2 _j'c{[jWZ^taS;vMpj*aq؅H W3V1hv^ ĝwDŽ>%>%܆W.•bORt0vly(؋!~^sWAnrCi2Q~>Y5-}OskIG;%>q~^>׭t KT` м[r`P)كј)'R)a-yU"3&2KoY7*C9fo(瓑%zͭ:lv_H5U0yCP@閙? ,%V24 A L KXv0F+>"&O*gr]Rp㴿_EynAگ}1&Ҏ=~jL>&WoۗUL{\5t 6ZxVHR\m_/}aW;keN+7FMQ]]"]R8 o nvhz;'*L)}voqA ]s 8c&ۢhCl {x O.;?~* g/vK8e#Hy˭^DF|3iJʼj$ t|`_//MkbtcOnuUK"ã<z;XB 9}`ݞ:ht~b9 Oϧ)32MW!=I^Yq;Q%{y]9!ݯgz;;i"GwE9^u E71Owq{j>/ OVv젎BaJ)0knAoCH4\?%`?]ׯ/<$/mHRԺ擏灱A,60dq޳uvZ5͙ߴbл7utu*+P}cxB9 (ʝ !&:kAw=S0V|cq,o/W˽r̂OrY٢u\.x/G44 Ԫ *q |﫫p_ %0QGڒhmr{# E e:׶b0E\Ӌ*[ Ɗþ?oSYjhB: N6/ ~hx1T.8߹Pl"sQ]:۴c1ݞЏY7^EOqؙjԊ[nk ?)lmiexIfx\tG[%jA@}昊忽¿+yкſ1%80X"P@j!%D,za#A ]9Ӽ@? &X%^I dm톣nڹ]Z cM(<ݥ \[F5F޶[9<scb7.Ř8w :}1"f10!MhǪK=N QsKoȽmRoy1sѹaHT;{-VhGYZ%\ /HyLNz[kUH.$rKU6œJylۇĊ\,~>GEzU/蟝&?728찕V 20\>+ok-Ufi2w8/ dhŤrg" ZH{ji4f/QȺ;KazlWsqLWOtY&Ai')i Z1U~ zSyA`˞D h&]KRxBGiϴIIU0" p.P_'9l8*}݌YIȍ,Q?Orݘ8AN6] 7ѵ? `ޑznpFYm~s]rHelkg# %}`V cw=[5~Ƿ!zl4s/`:qXK T:3DA>qd'P>2;@_OYj`2|v-7[bʤx Y?U)'QGS8~$A_%V f {S&ݥ&Fn]Pu]C_i7O>ɔ*)r7k<-ҵkp{5ozwn}N]59>,[sYq"6FO=lC4WPd^c921lo5Bu~Pob6N 7q-y;5rh0zvzkq@d*pύJ9+J2 N7"$: n! VpC?Y{o5+:g: _mF؞n*u=R ?3Pd;yYA7;~nju[G^֊D,Eu4ٮej*Y\?<+ 6N|G:)DՊfwQ-v|vg}n[-cxUFAKX-S<Pp$) Ek\znt<ͥvj<TFzޤ-z0xqJ.U嗧czXW|;/&&TdzR79T6^  _ޟ9vg:f=<)qܫ;\n lvxoE/\J:rx-0?^ !g@R&Ȧuk]舡*tSC7 WSiaU R.uaK4vjf~!^T=F?ݪ;i-Ӏ$v3|/= V.:f ):Z} q֘#kq;Y5*[=6hٞ c4?dNrQ~ 9I9EgIeQ6u"pFؚn8w^_I=%ܿ*R E/v.3Zk =v#ϙ*qXc?x(|rn<c8Y u. cUWgDԗKy ռt_/[(io !G$^l;F,(r۪P\xRH8$88 u,ޑ<0Shے U Foc8+W8x{ F9νV3O vO38?ìu>RZ=˸?r9 !咦v_eT`̣\ xyl^kj/Mh!#Hf9&罸)\.RUQ|G k$p8Whm6\x`$iV7e1bA8{(G J@ uj#=8Q|#l"z}bƅ$M%Yý'!Z HM߯]% ~&{" iRV.\jC[S$bA+v@;wW-l/Cy=O\FN2C}usۃzo?>?%υNw֭pNH/M5EtIQYW >1${8ӗ>W޿Y z4w˺H}ԢzјrkV ȹU qBˎ@(~E pzos> Υ.SFsK9̇3a4&ڮ/3"ʍ$\sMÍ~T=wg"W!x/SE{x$=btz>@=.0V4,!kZdIKΑQI/vGXaq'c5?95nNɨQ[|gCX98?郜:q*& ZC1·{"Y]v6J\]"Pg@ֹQcƈǐFK3W?ձB!+;7lW>s<\ݑq(w6OqBG`K(]c / :欥FͺkpNX3;9FM6 ?nͅ1a},_tQЊαgDlqs"V.iӀM~u%s sk~y6GSBBHJXdie7ٽw,P;n8exvY`mA}n /5;8Pzm= n^Dj؈ pZ^˹ S?"hD$.t >.d1 Qp>ezzH_ UP]EΝnܜ-w#M3EɊhqg!{C^Ɍ[2lPd(A#B^6ڇPɆ>]^)7CgڲϓMq+l%ML,(EoKředQ+P 1-dG$?+$ۑ5Pk=? W0sٜ &[DK7.ֲ`3 #yJ{7P\H~Z9-?tD̗l:6К{Lg~#zQ]X>)^YĢلZ-j1nE{:7Eeܷi*:n/VUa7J'SNi(B4UF0.y{JPvMYKĽxjäZ0fni('5219vxgaTQ=<8!ٙN;Tʵ|O *`/bmlp;tZ:\٧>,!{_lstXq(nkvh\v#9ztA3_ ͇?z})zx5.AMoH'dqĞ[g~#AV8Q..O_Uj~n\*4xux廳LNa$AhΣ&?gYiqOv4AP:_.jˈ{x= #(L%[I&)hD+ Ka$U=qN/u܍^Kos&dm&e*SAp*IRAF\2ŭ#zPV os# =*ӡ]`c:z]+|aXtSk=ۻ{o"V6SCK]lfuEuE"g79!S]vV֡KV2oFe&<fOμycQzrQF׌- K#j%7]A _)8 }S&mb>9؋Y q\+RL~1es;,g5c[6 _6"74WRP^}Swc"@)v.~U_I+=+C~Rn YGuGV/xݻEߘ; )#gIw*Y?KZ%ԓ4JN.P7yH~q a*g0rǑS1)Y+!Z5/Kfڽ!0fmj%0})2}}ͅ_" DI-433kd/(+`w|Q`oim7x,E>Dlm.},`х66|i$ˮr!~`f v' ):}cfz,Ͳh2c㣱X WG݆ͩ_wz}Vez5w lymGc`ͧW:滀Qn׽iԈ&^/[t-q$,?=Q|<{y"J 7|<$p+/h6~n .r}8A.llK"82TK+KȺ1xEn hл>)ȹ䷅s[4eWtHx ,`J2,(YMO,(6mUBc]70:fwm1B9Ymns=rd{.s<2G$lJƟ {X *TR R)*3ųAy֟E5M@;$T8Ly u3Ve훔x1`B:j>Fww$F/hIo>!bۖn޸Nz?!׊0R%6M$>]}l͝8 ?]yY }T)}UFCb =Ea/W`aw۶vgr!}O.%Z~퓾(7;]  / &~`XT>z훱ONuR0D !`-B]ߍĩk@Wr`;qNPZnsacaer;~ ,AE=5_z!lUbx  5(oE.=۶![w0K]AK  33[,}+4AW1Mз՘Elv'6,)5$lx ^A0Mo[okmT.7UHDu1cQ_z 9Z>=oyYp :h]{} k㸶8c1M:Q5M|E~p[_=֕]t喦MB徢XWN@Ǔ(A6)h'JJI|mMWC^Cʷ<%4-?IQkr`G~YyrSlN͕LZmBE <v"rrؚ,eI+f5Lxq%4|B>Ɠ$xƤ}eIG06Dr={ŶeޯaR /;2+v\sP\zؼjb,` _rh*>C~ 욇5<X' ?X^7ږ\6cn/U>*=4iH2q \܌3৐p ٽPjїo1&B%ha, xR°\ \Wخ8W5e'+7 nƴ_ViZ2ITF|E-0G WǔͿ%FG8z}fC9w.Atre߇*uGQ74tԬz?C3lhvzf{ԝ-W8Ƕ3Ejn{o[Gw'N&.ʲ:n[%~? m,4r҆z̲+2w|tӊ7cfvD-oY*n[4]rY&Զ"xvȅFe u=…Ojo'aj<-d>wt1RQF#˱hiP ϓgO(" ^"vLá%йGwᚽs߶WZ6|ۮ^u)ǁ4n͵m.{>mKaX.PO}OߗWeM.nXcdu*)ף(" YpD&{: .M_6ӈ_dE( 8ㄴHa ؐy4 } vhnc1450l ~y޵uEw?\y2D5Ft{ڙG%JQ>&"\ ԡ֑4ؽO -r=F06 )x}ux>V_Yb2{4gCt5Sn]i2+k=ǕU Z)Fc ͯJJ<⿶}7O}#.+? | .6hPzaFap~~Jv1(nn?nr(? `d EHpP>Ba:m`@=qqԲtC"2ύ)s$kyc)4俶07!<)3W?VMœ{&OrohM⼯D|B28]eyx?͚1`0ynt]DdX](J{.pHNY@}q<8ȹ0-d(sؙ F=_?~>EԔp%lf|vP)PD/\ȚrP]lF_hۻabl} 5šU`./wBJ@oX,F @S(Iaҁcs۲0/$b>5#4R]bybćNL\~t0hBaZpę H$(G'CqNe-i؏[6W禂ص$| ajTbhi1X&bFcE v%EY}Mp$ 2LafP;V3^UG>7kM=w |gֿ|!ts#[rUhMݘJ#?͋ /k7)z },K%~Wn`^DGIfpza΍rh}VCbyM~߼J_ڍB7E%>v{]R5wb[UYCٯ6ңXn],V.(W- çoiWjvnݗA?W#^`ĝ npt'WBUSoAih&\chSo3`UnR4N="DpuqG,i|ΙS.\\"-ܦ;cVB 7py'#_gîUsQ{oRJR⥖AK9aAr U$#?ވWC8?5DQ %|}f>ld!wK{?ʷ5rʇ2"_{*Ր%RVx43@omx^݇4BߣhhU<vgHPAۆk}ql\ohY ( JCuE?3ar5,BѺ 1~OVLzoQ^ Iˢq # P $ j^ZtdwMum#oɣ\a]Lk/Qu Fm[Xܤ{+90n$S wqm W_2?Wd<7L Trފ1$9sjQ^ۜ<6/LydpQKsVzOlE6,T3I>jԣ6e1)\u<"USԫcj\C +j 0I_;#"gKe3Z=L-\|:0H~/kVM+߽qyT7d_{Bk~8]UIdZ uǸ\fvjP4 H:HNVМB,Hq1FF96vW "-dlOmH\_b:CePhjͼ2.lǞ N]oNxYp>Ἦbx3>h[2P۵GW?ikUkT9^嶻o2m z= =xԝ4pnmֽ4^j%˽ -ƻyǻMT{\am2Ӧ_gWȉf;\jsUhŞAţg]ёhԶ{^O(4 C.Y~C mkcMAץN6RJ^>9 <ˣ0z4tf^^Vg3Td(\e|ېI7Z 1;c?yjm⢝2ҹ3u=b2LxƩc#EH44ѠUX`XЖzK:m&+Q[nY5C=v6~ jsdI[?'6wyCd{+7ZloSV=m~ @WyjRyК;yҳU>-Θv;<=f&'CdR DTjfN3Yk} ۜ->Q zӴOmm}D: gV81O $4|~ 7(#YɄ#9xsM$o`o}Z ¡IZ$jHfm6p"=y)RmW z_:n..y +"xrgW Ż%vhJ5KfN7B,V2[8gGd֛Zϒʔ8:avF{7-_ ᡯn.vKW;hr=n"A4Lхi¨@Tv{â̛!k6~p6C ƹ ajgeo|P'EݝjW=GtP=D3$YKĺ*wՂ_!8Dnvy&fvz;AGocA{;a Z˼ gFT\GHBz6z*[%R;RmX f~T~OxjndZB5Ćۣn!—q Y|tO}7Bb }L0h.U\v܅tM{2y8eFBV*Y]B!"}۟ q'6OrP)ﰺ\7r?j i_JDt+B}"xedb\8qĆ zr6w@ k~8ZYfت B"ƅع7b9l7?_+U_|$֩ZǸ曣/r}o qA*=__Ӫhu5@]N3d+ӓ҇=,%Ҍ3%T`tweAx}V2ݮ^T{yno2dRĉxn,W5b8BGB|mGp6r'YqB@K_Srt$e4:Gɩg|obŅVE|HO*]GMzUsr/ D^OWnW7~50W/'rA@b.O夁 ̉7EU]:\3rsd j(9cl 6#bR,TЏI5Uq%;Q߭eP| TF^>P_(8L$:yjr !tBCī;do~**2():LNi?߶&I^ٰzo|l  W8xOazby-QϣNo%]-xsD o^7s'ut' 줛!Y\ KY3|+| 7VI=ܼKgk`4C#*Ux?czbJH9t1 !XSJZu `'0]wUR|_V=K wk|WsQ^fpS֡ '=bI_ɐ7]%7\qwK -<6S(>VLf7pE_*vqu6XDF%i]6/4}#Ccx@J+cϝ=gI%^X -t_y|[.qrB-If\;*k )7gh=zDi@a2(q"GY~?N6zܥћyCj5D@(2++:(>U~i Cz/S-2+*gz@w1f\4_bI>0- rgߡ`_z8lu2WQ^5`C%]?kL1AxP^h~&VB1:hK햞o]%ě)݇LN5uE3\ -a,`WHu"6;M\@} A;b$F:G VEczA<6XHa"ru,.G=(e6@yMeUHԫ9rEvK,rbRsd{NK#/OӰ"z73%PyԹ6U">Q?O&wym>JD]<.?(ƟQT;`lP/*A,T{F&Fsڠd)셷Jpl;"?W=f6ꮥ&g0fh[TdQԩ0Faqu`nY+#qǣ%4Ӎa-hBfK}WǁzӗV.[|`[ݷx\+}\6܁DU+%^ivߞ y,}s<2 5kpC 03ei8y/[LsخМ"vadį|=YPtuZY{>.lYaڛt3Hd|рHR.>U%cBz/Wp`linfTYgp]CɾKoktbO'Pw_qe>1=E1T8)'?4?ByW8 =en mXQ|QזH3tQVm5YgjuڃPz7|md\wY6niW,nfEeS'PRMX; ;0d|ѿLƱYlD5b>l,1 iѵ}o<3vG-/|o2P9]dzlEw>!a }g+^%:^@>'J[4bfFwdp}>GRpY#iv|9W/Jrqq&>I߶wqwp'1\tڎ8J R*вBb!WC꥚YT{"31AbϿ^KCz!??Yo"7qy?O? C^647KK®A^y碧0m9rG4J$tXf.%"R&tz:2sv*GGAʏ}%8%eY^KȚܡwHY/Zx,*™ՙlqd7xf: gc['9䙇 &Nb\k4̨dA^:hn+fQt\yO{'6dAc"IXZ2cc?2ػ;Hdnz( yFˀIi_hu򲵩{S=*x^x-Rp{x/HL6 9JA+{! j2ӛ<ΌkM g[6}h-ǤTXg?{_ ^F" ,8~ 8[̀-p_pP!Enuۼq̱,x- G,a7bGshY\=;Z ׍Gy`6ܛ;Hs9=;R;{Y5ܵ'o=r+C`~so54 O xA3N%dji\t_Gƃxs7r;'tV,k"wٝ<)0!^ Q4l58O2tgwMS㣑'{YSͺEۘc}Nu8iqc2Ҳ+9 &}"dF6uupQUx <>kWGWZ=y_g`&DaA`@KC 3@o+^p+WnoR6Ru wྪC®R6 -C|4eo$6|QeLv\=rsq,zp8WTx0'.GRHE4 E6 41 =fF>`ȟb4i+Bb[9뾇/M)Zo 9 N7@t JQH5{`ӎw<FmBwpkR~ŖZyunI46q@m筁f1=P{:U:VPF`U"IKL^<[sep J/W]Ǡ&UVnkQ٪8nd%;\L{rd4Apc1?;{Y0Fl88;7`vT-Oy)zLs9v0doyec6ʽsꗖ5~#KU KqDP1h$XuIz&Q$TVr~l~Q.~[s''s?\G=Bz%\{R'Z d|+JwGUg 3i^ >5놄N]#vhH#~?>tQm*@]S"EȪAY'rǢ'D/Gt Y-J-?_ך>5$=[#-xQjQ*.3whQس4 x6?8b@spٖ5|F#_QutZdk{ẓn=N F'*naT?SsaT_*uIe8wIWW 9WrjAr%Ar2 $67Z,-R=W<9%TJEl8sڕc8OnK@G,F4,(2txd.i2xPguNѕ"ŶhY;5~{j7=ibXZϭ40ٺ%EX5j]GTt\X07K{>G6.A(2V!]f2"4 h[~<"%Ol$#U J#<&Qd޲c8kakraԫp39 0R/!X&HK 0HQj(՗@o^Ց)) !Օׁ=& ?J}.*Mt},f]j-+j/y~s;f2򭳤\Rݢߨ@r#GFn ztbVl](#̷lѣ-zgE,? co'UeL۵l~57רs IhY 7[T C&0:agAeY/;[d;ł=(D073Ðߋ*/{@E-/sO1L:=jiJFѡ6;$r@旃`[Eq!#qeG L݀D#REݟIݹ{r/O2( POR{Cy.ޓPÓR%!{@ ~v's@t tM1Uhx+dЇzM@Vy,N'\R;Xwj%irI~[ӡƲpb徜WL3x@@)>BOG2DW tI訶׌ܨ[/rЄyb' 30:)3L3N1?Ţo~K#Ar22hWXEvvu{_jeabB*<zH(7ZvﶨFw~9h>J;w \bZI B(yMqJKsc^6SxfawZex,k9dSH^n5D%R>jؚ@S6 OVP09l,j!:-Ggi{ /k3y:=w$cqՍB#l9 iў'~>]}RZ{(`;+ZJp+P.4k %)|Po$PQeO ""ApX0]gN< ju@c.+`(RxOPu5_#۸Uޓ{2̯w {{_˨ѠޱzTdRf3dqU* lHjϗ{z8,gEn̾j|L]j }ߟfoz=~Owb]چt hK~:U,w{Aw*~Jn+OXo;12q?[f{eWy9ȖDRi3qP:a6{^l*EEYaK]^핣q\ڰI=G'>G@/Ҭ7:P:E:}D(?̾݁ޝv9S ­%ü*<zbσm Bv*A V P։m%GYH8kg&" ,r dt4|){@>H."Mri+7ڴa]RE]=lA>&*2b'}:R.GQ!a/(%(V`\sQ~_8`|_WؙR#42{wMS5:;>L#>,:^VW=KYWml硭jxwE-f@wXχ8Ӹcqm P,La! l>]^s֯jN{>&m Y#x7 kN~Z_4 ͹~em`r20!PAnBHooVCHPq4axsC_EQnp~07qR=e|S+b;Ӝ\4Ǚatw4P~</{3?ޏcхw5Z_ȊlՉ۴w% tbb>4XT+uAYc@=mT; F̻T0:EG55ayJ4F| N,Wϖ ɚK=PIw&)CLW@-~9?-[$Sn+kUs$WAN&KvHOܼ-N_/Nx>)i ~/!A2h9m d+ia2YLkqK97£J,_N~rMgVe!"VT#9P9gT^,Y[ƒvEؖa}+hc&[6jC&Vd5laG^AL,F,wekl־GG¸ Ɲ\Nη ol6C=cJ. AzTl=KhGM ZQ_)AlrUZIB:5=b6ߋ IjX=Q]?cp݌<ه2?Rq}d:ikFUj2"[S+| 2 ť1@3'[^G@(o<:G!֦ DL4FrH*1@<g3$Q?Ry{= ~>::!mTҽc>t3Yu2~_̓J*S޻u!=Y([RaˈTj7Z\&NrN j阭XI*j I<-e8"pםF\Ij=LPz]Ӱq#Kyfym2LƊW~O)v;7䕰%)|f6  9ZNT= vJ(*Puz(J]doO.2/VM}̅˩ThJƽH<ƒ@'~?_x6* qY;'R"NЕ^A_ڳRu6' t5YȄd?D6t,u>&lP,v~x8BO ~qί}?lm|.77n kQ#54H6ЍBOʝBdYn#8nw6g"/[ۿ@hNWzq :rwr&Ӛ:s 4-a@6h>s=^ %ŗ2W;J̥!ේ\W6cx Cca;n9}3pvj.Q^#{xrh _$ubQ:k3X$?vP =d?lH =݄c|_q!%hЇn3D ?c=t]\E{rVk~fin8IR r'iYqFv7tR_r[JLrtQ@+iudg6%r ɲ::Rn{րw3alSX˯T~#P 5zuֵHB'DH_+WPޫ-y(#M΍k⏶&C} =;}*TPHuidш50tiZ1{6p/"90N$c25Mw!9B$ Cn*ucNm1K%Q @>Sa8t34F8ǫc:GVP@vw6w*vS'9֫ƔtoL&%܄QvuvN[ЦO! y5e!x:ZάD쁒<RkFkɰʶP2 ¹컂 虱hSlu=eOx:cGЪ7}^Z A5)%ƛRc Iawt{Z99VEr80fl=cڛ=>(޷pЫ~ ;lUm'!t {)q'lZe[4SqUQ/io[ɶ$;hG|~\d~0?45Ea gD3yZ+rǍ1fEl4pKs.Zj?7 qԶx6ݵ=#/ NpY(kD;nkMXh zc@"*&"hJ%$0@A=o lwѥn] Hnc"P,TJ=7?o"$YLռ:sÛI-.Ǯ$#)mNZ J^GR@_et@ OIBQsbա7#qnbE- f+t>B#6lz}彊ĭxv?#)}-8srܴ)v*byal+R GP,s*GA7x7=ן"'A@k"h3 'g? hh2JDjg@&Ľ {1wU aisNy=pwR#xs9ޤK'b~7i"Yx8mHw(Ya"tLؙXEC0+QZgX߂Sm[v˛)7/w{JcEmadF; ۀOl¬]W Sg=xېàu8.y<+f3\ft0ˋŹx& `i2Y&UuUr2A)װ@<;4fE1n[Jse3dDE2}_=)=^&n[RWG%+:8|{?alfy5~Y+qm1vC/MMkmվĥX T ۴-2 'd-"g%pu>ƲTlUZEx} iӳa-o$2XvZ-F3Mp/&T(y>?^+ U^=!CR\aOԶ>b#(o'! IrhPͱemMl-RM¬/1%|'s8JBI/r<N%hPP#_lZ O"\CI^o9g-%4lU{$g^oѭlGyb\ 'TXO&X|վ]IgWVsH7N3)wZ(0,6H28;l/ǫJa;ҭbV1.end~j~0nj[;(2jt*>MgT<,(+P=ODeW,ٔ;Bu!W86:ř?s}Ik@" h>渘/"Rav Ѐ07bAAW?͓;kl6qpqj2-EP ytg+E(mvBy%Ǚ =_ %xn42Psߵ2уKy<'&NБ Q3&Ex|Zt MogMiYu™qTTٺ/@Ȭ30 )O9qw}-b(ShRP'.6Ƿ`|ã G -iƦ \K.E4%HE8֏:::=FV|/pāRS_Ftb6_.O{[nGJM:w!X{UX׹SgMLy}|\&_Jk}x\a&5~Z U)k-M`[1ssJ$mt&=פhS/tX<#q] gzgP <4{ߟ=v~0wc_ؚL]R,okpJxQeR_VS&GQ6 BW'LdjϽ;@=1wK }7F:컽%<[7Ev!ix S7қ~i&}lN=fK%o.c7c |eZK!lO2-=sc-y~u"[%y, ZWEHOSXQ1ܟırxtUټe9!S7ك QԀ<&RMm.g bij_h_SaκkVNvsOfMfWwr Lo' q)gbՕl9ȍ 3e}cI*VWvFuz _Tk,F阁{fro諫c9_`; !SofZ_ۚGfԦ6g`|+D RgL2Bgzw|c.4=߀<;["1q< "}%[G_fj"Hhg[ 5d'E,rO[fBsj1͞ VzYoϙI m]ْ@ .=l"" ê#|g B!998'XFVZrC+Z#>nkʗEvBat?Wo }2 [+*i+z'G G~R!m؝[53 6dH(0q J;b )R Prp7Y=LEllQHafʲ[co#[ 53&3հ+ o*dEknTiQ7BߢDv|^ϣs+h6Į!mh.vZCrb`K-L/53NR,uԶi#ER #Bi΂JO)P0|ÝR^vbic"1P Z-L΁fh oYMncz?B=tK^N??=uڕ?BZ- [X}'.L(mxH^miUĞ?@%!$bc6egС rNA5gO;uH;[|qx4Wx=mlSuVW #2 5 A.1etmRK [v}[ֵ'#8 sHD DQ&0Ad  !Y3ٻ}\tb$q8QOSvW4iiUu).h`@;*DCaIXQWQ/gk؀iԛ| qcsA=% Zۤ'\1[[WZ `l?3xŹ;yK7ekc3`ˀwyjHݽ)O@jg$--˼ȣRqE֜{JQc|;osȽ!y⭎^̭Ew$Č xSsg7*+sG!(v} +K{k7W#Mo5ƙwuZbf{K²S݃U DÈT&sPؚsSQCzcHIx^MtŤbɉcN!N/??#PÈ=Nlgtm }8Ơ}tG2\:9_QNޣSqvvVO`$3N&xib  2 J|+L̼½\s̊KS+ |\,C' t2Lu,s]xC 46QqM/ȃ@chOK100644 go.sumUuC9XhB£@j/.MZSxC 46:yf2WuC+$Y100644 go.sumcho.(~4u渣2aj/8ox{^g FyD&a427]$ &x{^g FyD6=$ @2jxi| .\7ucX x4 . y ,2 2\3] ML Bs Ss<ݳ *|B"=\\B*M& 42ZNuܜ q->xC 46ڐDn+NӪT}100644 go.sumJ(1(:]N9j/SxC 46w,Q^R=100644 go.sumL;pig{wCvej/kmax{^g FyD6=$ @/x{^g FyD6=$ @0nXx4 Λ]ܽ0x{1wE5N< VކQɾFY!AI%U9&%پAQ D@7p   xu Tm8,M %frKa6NT禥6100644 go.sumļY糱W1ɕ*r:NCjsZ,qVhn8f3ݯ4xC 6v. +BƎ@100644 go.sumHPQ8xx,.=eRc9@/Rxd >ATYD"`.aD100644 config_test.gonU~?0O8rڳ*I 0I26<3oW&Rx{^g FyD6=$ @~,x{^g FyD6=$ @.Ix4 N V&.iNy!~^fE٩~^ie~UA m'80Ouܜ 4{Zx{1 N Vy^)yEeIEeQ!y~Ye~I^.e& m'80n41xI=~9مXW%yF100644 stats_test.gorDmGhdE6bBII7^FXxI=?*_L} ##100644 stats_test.goCJUN$|3 ix('x;~{E%CB44u,G`gW _O?lׂ MXpqr*ƃ46ϔ$#fx?// // Only blocks that carry a time are counted. A single row whose timestamp // parses to epoch 0 anchors the span at 1970 and swallows the whole index: // Hanzo has one, and it turned a chain producing a block every 11 seconds into // a reported 58,370 — 30,602 blocks over an apparent 56 years. Zoo has one // too, reading 2,389 for the same 11-second cadence. Excluding them is not a // threshold, it is a definition: a block with no time cannot bound a span, and // counting it invents the interval it appears to measure WHERE `+blockEpoch+` > 00*PgTxwr5{x!MT& // One block with no time must not become the whole chain's history. Hanzo has // exactly this row: it anchored the span at 1970 and reported 58,370 seconds // per block on a chain building one every 11. func TestAverageBlockTimeIgnoresATimelessBlock(t #D#5) // five blocks, one minute apart#z$?%z',999,?,0)`, time.Unix(0, 0).UTC()  \%DStats, %stats")!(float64); got != 60i%8q{Zi2ۜbuSwnvђrB;$MxX~rz٪gȽm߼Kg 2<'?l-PZZTY_2ɳVq{^3GB4jxpF˻LU؅&0L)3ـmr Jfs}̞,%`z7\'j35- x\rv}A[䆨f _;85)ly!.F :h,EF2n&B%/Gֻ,]./7D% 65yE;A€óhd#-ʪ`E>[EAHY IjqI|:Væs`;Zw!q;*@4z/Ef:[n57[@e<|q>kܨ0!5 N5niq^pk@uyn vu+x]zSz9_0))u.JTp.Vu5[P)W>4Cj@k]WD}J,DZmap- M7M B3DH¬1,9l: )ߍ;' 7_+6IX=$0cIkE`C<2on7Xb˱ ds UN)_LF0k&CYAzt\m1Mվli1NVw?EZN @XqQH8x7A@6͢XāU[6{ چڌ$G+ɪl+&YGUʄɸJ S[{ <41qH@5C!ijb$Yr uL#3LcZG;L Rj#.%.u¿ q:)g:F ~]'w`+0'?1_ (HBk&a_]\{75GКiaGYP!Wm%$,ұ`d3M`hk Q ܕY:%Q\f\ղ1DfV$4հ0mm@;OB. FƸWbj0YHpXtf˚f eĘd۬iA$/^>;<:vhĶ_~:.1lnF_(`GNxv N:}?D҅DFHbƗ~nhrk!0" g' "6do'*^ݕK4 |o#*܆5FIx<9D_w{*a6%qF֏cpho|B .7Pxˍt2AxQa ɳ'8TYEΟ_=Kxȣ\R0IXy.<b뺖ɡKeK|ͤP‘fV".ԞMନi_1'&Ib`&bY. MQEfhg\-,!tw8Z!pp}Z':  WQ<{X/t-Ψx:  F{-Cho-E۲!y*k,UE\>?!P *`CQĚ@.}ubIa`EUn$gF<tF?1Qk?'2ejAGÌI NTAt.m03;;Sh#1"jb)V(qiN6Ys@O(=`wH0,͚'Og`3Jt:Dr?3_W}~琫aT\q:׷v;sd~Rq9u>C ;z;t'{a$G"KnCv?^5T6}/rT0Jc!x˭sѺF7jZdTTgp)99ܳ+Og>R`ΑC;}W?I E{ol\f/ƮI pXs8an8 2y u3 sj&Lұjg"`^y3K =*\t0-Z rC%K;pTbIzƖU["[pE;,ҥolǵiEmSȥɍMnѲkCm*(pByyyu=gFQ ݓd!}g3QeG0!\ؽKVQ* w\kEdu 3 e4rݍBF *r:⺂U4t]E(@eXZx#髽@Ɉw_0#D̂ :f^[=r*kqxvScZN+p+W#BCS 6Gm^9FaCB&ND,ƣms+rPiy жϡ(Fd;-% ꨊҏ'z\B;z萇l,KYSX _;A#<3}D3dVKΜ#"R~&6HG<Hi_d"1T@2($ZT8EP(p}pN{AFf㷉3=o갥PBf <ZͤjsYuoQf*65K쫃"CN,0wl8fvˬaV%XU #>j;J\s\F8dTh6Tvw:8t؍4n FqV2x^qc ]tfYұI~I5Z86=SNRVoȘbHaI}e&c0I),R!tuŌmtS/&脡/'$;ZnII5d ZǕ'ƬQ>=7z*7*vg$eO,#I2 YP/]Y9ܷ,¤S؆Bx!$8+jLmZmВP#XFY&4 xxdJBYg$3f{N*A1Ot PR6B3ѱ>96&լW[4S'LHoQRvqa7!7 6&=4o"?f|N<g#';A (>ʗEAS7K(_#Kf(s+J^Y@ً]H$w3bA<apwM|\"gF$.%y ƈTN]׼霞ӱԗ2ֽHu4n 'joCsCP*DoEz^]UUnzǚڠgkn77b&V$(%:4?[:toOYm8-!.3x=;9#ɜ~|ݩ) k0AR2dY9`bĒΥL|J7jPTNiusߗnPֈ\f'֢! 1A@V {0bvOw< ,o1*"q2C~z4`%_{QAE,)*QƼ@TKqԞ~y+r@)5qII|[E/&bDwہ0_/@iWSXfW*D0ED~s4(\ѹB-+ %E&"gL.iWТ58Oؔ%}Źau>_M b.EOJ;m\Y*QKel:UtnvDnKVl0)"O|dGWf>Z^KcrnHz`۠ec$^&,<׃r讒)Ol#iEt_ z&N)tk,m!3>zFك]'~ )NqcPtxh8~B/vm1{mO{ Gvx2@v᱌Zw\l>Ə?LjeIτpڣ &69p £"դTΟeCz1OK}2tLjHN>%"{tGVׇ;ͺ>\`9>H.AW#n)+Ő]rh.R|(xkd@:Ȑg9ȕ]<}/ٲG/~"lԳl?eOq[ƨmyfuhA=I@열}D=2wyoa* Ð}&*p_ȟ}46Q3.I?ū!/^Z7x\ʖO" "net/http" "net/urlTUG browserRPC(c)GgbrowserRPC picks the RPC URL to hand the SPA. ChainConfig.RPC is the address // THIS PROCESS dials, which in-cluster is a service-mesh name; emitting it here // shipped `http://luxd-headless.lux-mainnet.svc.cluster.local:9630/v1/bc/C/rpc` // to every browser loading explore.lux.network, where it is unresolvable. // // Prefer an explicit public_rpc; otherwise pass RPC through only when a browser // could actually reach it. Returning "" is deliberate and better than a URL that // always fails: the SPA can hide the affected action instead of offering a // control that silently errors. func browserRPC(c ChainConfig) string { if c.PublicRPC != "" { return c.PublicRPC } if browserReachable(c.RPC) { return c.RPC } return "" } // browserReachable reports whether url names a host reachable from outside the // cluster. Cluster-internal DNS, loopback and RFC1918 literals are no3t. func browserReachable(raw string) bool { if raw<&u, err := url.Parse(raw'false } host := u.Hostname() if host<&3E=A|| =svc= internal")B:host == "localhost" || host == "127.0.0.1" || host == "::1A&ip := net.ParseIP(host); ip != nil { return !(ip.IsLoopback() || ip.IsPrivate() || ip.IsLinkLocalUnicast() || ip.IsUnspecified()) } // A bare single-label name (no dot) is a cluster service name, not public. return strings.Contains(host, ".") } // H5x{^gNFy7]$ AKxYmo, _D8nq)lǵa$+reBvI>>3(Yr.hE.3L)/FuKc+{ҩr}3aa:07U5UUI׮ttYsqqWzf>*i>g~4Ts/])m]:1?>.Tr2qI iwP\]Æ:CרV lHww&JJ(lX?]JMxj߱`:C+j/C gɧ*-&F!?՘s Կv$m{HҺ5$P_VVqRP[(mnu=([uJYi *Tvx[% ȿH]%r'RSU*KZ" (s,9$)i5PE*Ƈ7~K*˪@B{ncH$MSݕ"{rrAEl. M]x,$R6%wgkDbLxVgt?qrV8"M4!:8Pɛ,0 u6)3xWUCK 6*k)!g9 <́Go"f <[kJ2AY̷C6Ҩm;ruP^π\HX!bƭ̀{7"HSTBۀ_jes>q1q-NhO4pD+7QrZE U,gb]ό"-`0Т_ghNSr 11.$5yϾ{wؠǖ2DznTE&; @u@%Zm)*Œ-D^E~)NYStQP4*i·\8KxCxv^23hN|{QYtvؒZ#F'NSR,Sb*y}Ǘxͫ{C>,3tL`X"S wO;=D/kS @N@*ؘ6'2) Y~ǝ պh`Nr±BaQ/ae 2;PH䀄ܰʕ5 ;}IUz*ֶ$ưuAꚵɟXXy/lbޖ7 ᡈV9Oe ׮?^5xwx?&̉E+m/R7w,h9 pYJã$@٣f%f;VSYI>OY9Lc~i~\b1ࡂZ4usū$ݎP-a8!^4MA#;;QbCwBI~Ȉ`EwjWiNm JmP*"q' & ͌~UguwLmvOS9}E4M 7̖hě|ATW;Hc5OMv1y y8iBW T?}pbж Z܅/mtmcAzLʡpB yHKx֢5".np7 &Ca whvj _9;9d -N_!N>z+qc$vmprސWE Ng2ly]'nEީr#pKxiWeeݒiA jnx!N% ` =zQ$7[aj??#x) 3Ubytes" "encoding/json" "net/http" "net/http/httptest" "os" "path/filepath" "testing" ) func TestRegistryAddAndList(t *testing.T) { r := NewChainRegistry() err := r.Add(ChainConfig{ Slug: "cchain", Name: "C-Chain", RPC: "http://loca@lhost:9650/v1/bc/C/rpc", Type: "evm", Source: "config", }t.Fatal(err) } if r.Count() != 1 { t.Fatalf("expected 1 chain, got %d", r.Count()) } chains := r.List() if chains[0].Slug != "cchain" { t.Fatalf("expected slug cchain, got %s", chains[0].Slug) } } func TestRegistryInvalidSlug(t *testing.T) { r := NewChainRegistry() err := r.Add(ChainConfig{Slug: "BAD SLUG", RPC: "http://x"}) if err == nil { t.Fatal("expected error for invalid slug") } err = r.Add(ChainConfig{Slug: "../escape", RPC: "http://x"}) if err == nil { t.Fatal("expected error for path traversal slug") } } func TestRegistryMissingRPC(t *testing.T) { r := NewChainRegistry() err := r.Add(ChainConfig{Slug: "test", Name: "test"}) if err == nil { t.Fatal("expected error for missing RPC") } } func TestRegistryRemove(t *testing.T) { r := NewChainRegistry() r.Add(ChainConfig{Slug: "test", Name: "test", RPC: "http://x", Source: "admin"}) if !r.Remove("test") { t.Fatal("expected Remove to return true") } if r.Count() != 0 { t.Fatal("expected 0 chains after remove") } if r.Remove("nonexistent") { t.Fatal("expected Remove to return false for nonexistent") } } func TestRegistryUpdate(t *testing.T) { r := NewChainRegistry() r.Add(ChainConfig{Slug: "test", Name: "old", RPC: "http://old", Source: "config"})F err := r.Update("test", ChainConfig{Name: "new", RPC: "http://new"}t.Fatal(err) } cfg, ok := r.Get("test") if !ok { t.Fatal("chain not found after update") } if cfg.Name != "new" { t.Fatalf("expected name=new, got %s", cfg.Name) } if cfg.RPC != "http://new" { t.Fatalf("expected rpc=http://new, got %s", cfg.RPC) } } func TestRegistryUpdateNotFound(t *testing.T) { r := NewChainRegistry() err := r.Update("nonexistent", ChainConfig{Name: "x"}) if err == nil { t.Fatal("expected error for nonexistent chain") } } func TestRegistryMDNSPriority(t *testing.T) { r := NewChainRegistry() // Config source takes precedence r.Add(ChainConfig{Slug: "cchain", Name: "C-Chain", RPC: "http://config", Source: "config"}) // mDNS should not override err := r.Add(ChainConfig{Slug: "cchain", Name: "C-Chain", RPC: "http://mdns", Source: "mdns"}) if err == nil { t.Fatal("expected error when mdns tries to override config") } cfg, _ := r.Get("cchain") if cfg.RPC != "http://config" { t.Fatalf("expected config RPC to persist, got %s", cfg.RPC) } } func TestRegistryDefaultType(t *testing.T) { r := NewChainRegistry() r.Add(ChainConfig{Slug: "test", Name: "test", RPC: "http://x", Source: "admin"}) cfg, _ := r.Get("test") if cfg.Type != "evm" { t.Fatalf("expected default type=evm, got %s", cfg.Type) } } func TestRegistryLoadFromEnv(t *testing.T) { r := NewChainRegistry() r.LoadFromEnv("cchain:http://localhost:9650/v1/bc/C/rpc,zoo:http://localhost:9650/v1/bc/Zoo/rpc") if r.Count() != 2 { t.Fatalf("expected 2 chains, got %d", r.Count()) } } func TestRegistryLoadFromFile(t *testing.T) { dir := t.TempDir() f := filepath.Join(dir, "chains.yaml") os.WriteFile(f, []byte(`chains: - slug: cchain name: C-Chain chain_id: 96369 rpc: http://localhost:9650/v1/bc/C/rpc type: evm default: true - slug: zoo name: Zoo chain_id: 200200 rpc: http://localhost:9650/v1/bc/Zoo/rpc type: evm `), 06444) r := NewChainRegistry() err := r.LoadFromFile(ft.Fatal(err) } if r.Count() != 2 { t.Fatalf("expected 2 chains, got %d", r.Count()) } cfg, ok := r.Get("cchain") if !ok { t.Fatal("cchain not found") } if cfg.ChainID != 96369 { t.Fatalf("expected chain_id=96369, got %d", cfg.ChainID) } if cfg.Source != "config" { t.Fatalf("expected source=config, got %s", cfg.Source) } } func TestHandleList(t *testing.T) { r := NewChainRegistry() r.Add(ChainConfig{Slug: "test", Name: "Test", RPC: "http://x", Source: "admin"}) req := httptest.NewRequest("GET", "/v1/explorer/admin/chains", nil) w := httptest.NewRecorder() r.HandleList(w, req) if w.Code != 200 { t.Fatalf("expected 200, got %d", w.Code) } var body map[string]any json.NewDecoder(w.Body).Decode(&body) if body["count"].(float64) != 1 { t.Fatalf("expected count=1, got %v", body["count"]) } } func TestHandleAddAndRemove(t *testing.T) { r := NewChainRegistry() // Add payload := `{"slug":"cchain","name":"C-Chain","rpc":"http://localhost:9650/v1/bc/C/rpc","type":"evm"}` req := httptest.NewRequest("POST", "/v1/explorer/admin/chains", bytes.NewBufferString(payload)) req.Header.Set("Content-Type", "application/json") w := httptest.NewRecorder() r.HandleAdd(w, req) if w.Code != 201 { t.Fatalf("expected 201, got %d: %s", w.Code, w.Body.String()) } if r.Count() != 1 { t.Fatalf("expected 1 chain after add") } // Duplicate should conflict req = httptest.NewRequest("POST", "/v1/explorer/admin/chains", bytes.NewBufferString(payload)) req.Header.Set("Content-Type", "application/json") w = httptest.NewRecorder() r.HandleAdd(w, req) if w.Code != 409 { t.Fatalf("expected 409 for duplicate, got %d", w.Code) } // Remove req = httptest.NewRequest("DELETE", "/v1/explorer/admin/chains/cchain", nil) req.SetPathValue("slug", "cchain") w = httptest.NewRecorder() r.HandleRemove(w, req) if w.Code != 200 { t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String()) } if r.Count() != 0 { t.Fatal("expected 0 chains after remove") } } func TestHandleUpdate(t *testing.T) { r := NewChainRegistry() r.Add(ChainConfig{Slug: "test", Name: "Old", RPC: "http://old", Source: "config"}) payload := `{"name":"New","rpc":"http://new"}` req := httptest.NewRequest("PUT", "/v1/explorer/admin/chains/test", bytes.NewBufferString(payload)) req.SetPathValue("slug", "test") req.Header.Set("Content-Type", "application/json") w := httptest.NewRecorder() r.HandleUpdate(w, req) if w.Code != 200 { t.Fatalf("expected 200, got %d: %s", w.Code, w.Body.String()) } var cfg ChainConfig json.NewDecoder(w.Body).Decode(&cfg) if cfg.Name != "New" { t.Fatalf("expected name=New, got %s", cfg.Name) } } func TestHandleUpdateNotFound(t *testing.T) { r := NewChainRegistry() payload := `{"name":"x"}` req := httptest.NewRequest("PUT", "/v1/explorer/admin/chains/nonexistent", bytes.NewBufferString(payload)) req.SetPathValue("slug", "nonexistent") w := httptest.NewRecorder() r.HandleUpdate(w, req) if w.Code != 404 { t.Fatalf("expected 404, got %d", w.Code) } }  func TestHandleRemoveNotFound(t *testing.T) { r := NewChainRegistry() req := httptest.NewRequest("DELETE", "/v1/explorer/admin/chains/nonexistent", nil) req.SetPathValue("slug", "nonexistent") w := httptest.NewRecorder() r.HandleRemove(w, req) if w.Code != 404 { t.Fatalf("expected 404, got %d", w.Code) } } func TestHandleAddInvalid(t *testing.T) { r := NewChainRegistry() // Bad JSON req := httptest.NewRequest("POST", "/v1/explorer/admin/chains", bytes.NewBufferString("not json")) w := httptest.NewRecorder() r.HandleAdd(w, req) if w.Code != 400 { t.Fatalf("expected 400 for bad json, got %d", w.Code) } // Missing slug req = httptest.NewRequest("POST", "/v1/explorer/admin/chains", bytes.NewBufferString(`{"rpc":"http://x"}`)) w = httptest.NewRecorder() r.HandleAdd(w, req) if w.Code != 409 { t.Fatalf("expected 409 for missing slug, got %d", w.Code) } } func TestEnvHelpers(t *testing.T) { if env("NONEXISTENT_KEY_12345", "fallback") != "fallback" { t.Fatal("env fallback failed") } if envBool("NONEXISTENT_KEY_12345", true) != true { t.Fatal("envBool fallback failed") } } // TestHTTPIntegration uses a real mux + httptest server to verify routing. func TestHTTPIntegration(t *testing.T) { registry := NewChainRegistry() mux := http.NewServeMux() mux.HandleFunc("GET /v1/explorer/admin/chains", registry.HandleList) mux.HandleFunc("POST /v1/explorer/admin/chains", registry.HandleAdd) mux.HandleFunc("PUT /v1/explorer/admin/chains/{slug}", registry.HandleUpdate) mux.HandleFunc("DELETE /v1/explorer/admin/chains/{slug}", registry.HandleRemove) mux.HandleFunc("GET /health", func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(map[string]any{"status": "ok", "chains": registry.Count()}) }) ts := httptest.NewServer(mux) defer ts.Close() client := ts.Client() // Hea/lth resp, err := client.Get(ts.URL + "/health"t.Fatal(err) } if resp.StatusCode != 200 { t.Fatalf("health: expected 200, got %d", resp.StatusCode) } resp.Body.Close() N // List (empty) resp, err = client.Get(ts.URL + "/v1/explorer/admin/chains".t.Fatal(err) } var listBody map[string]any &#listBody) resp.Body.Close() if listBody["count"].(float64) != 0 { t.Fatalf("expected 0 chains initially") } // Add addPayload := `{"slug":"cchain","name":"C-Chain","chain_id":96369,"rpc":"http://localhost:9650/v1/bc/C/rpc","type":"evm","default":true}` resp, err = client.Post(ts.URL+"/v1/explorer/admin/chains", "application/json", bytes.NewBufferString(addPayload)) if t.Fatal(err) } if resp.StatusCode != 201 { t.Fatalf("add: expected 201, got %d", resp.StatusCode) } resp.Body.Close() /M/ List (1 chain) resp, err = client.Get(ts.URL + "/v1/explorer/admin/chains"t.Fatal(err) } &#listBody) resp.Body.Close() if listBody["count"].(float64) != 1 { t.Fatalf("expected 1 chain after add") } // Update updatePayload := `{"name":"Lux C-Chain","rpc":"http://new:9650/v1/bc/C/rpc"}` updateReq, _ := http.NewRequest("PUT", ts.URL+"/v1/explorer/admin/chains/cchain", bytes.NewBufferString(updatePayload)) updateReq.Header.Set("Content-Type", "application/json")! resp, err = client.Do(updateReqt.Fatal(err) } if resp.StatusCode != 200 { t.Fatalf("update: expected 200, got %d", resp.StatusCode) } var updated ChainConfig &#updated) resp.Body.Close() if updated.Name != "Lux C-Chain" { t.Fatalf("expected updated name, got %s", updated.Name) } // Delete delReq, _ := http.NewRequest("DELETE", ts.URL+"/v1/explorer/admin/chains/cchain", nil) resp, err = client.Do(delReqt.Fatal(err) } if resp.StatusCode != 200 { t.Fatalf("delete: expected 200, got %d", resp.StatusCode) } resp.Body.Close() O // Verify empty resp, _ = client.Get(ts.URL + "/v1/explorer/admin/chains") &#vlistBody) resp.Body.Close() if listBody["count"].(float64) != 0 { t.Fatalf("expected 0 chains after delete") } } FHxDUBcontext" "database/sql" "encoding/json" "fmt" "log" "net/httpPstrings" "sync" "time" _ "github.com/mattn/go-sqlite3" "github.com/luxfi/graph/engine" graphidx "github.com/luxfi/graph/indexer" graphstor "github.com/luxfi/graph/storage" "github.com/luxfi/indexer/chain" "github.com/luxfi/indexer/evm" "github.com/luxfi/indexer/explorer" "github.com/luxfi/indexer/platform" idxstor "github.com/luxfi/indexer/storage" ) // ChainSupervisor owns the per-chain indexer + graph goroutines plus the // route dispatcher that maps /v1/indexer/{slug}/* and /v1/graph/{slug}/* // requests to the correct handler. Routes are mutable at runtime: adding a // chain spawns its workers, removing a chain cancels them. type ChainSupervisor struct { dataDir string mu sync.Mutex state map[string]*chainState indexerRoutes sync.Map // map[slug]http.Handler graphRoutes sync.Map // map[slug + "/" + subgraph]http.Handler defaultSlug string  // serves /v1/indexer/* (no slug prefix) // realtimeHub is the explorer's RealtimeHub. When set (via // AttachRealtime), the supervisor wires each per-chain EVM indexer's // Subscriber.OnBroadcast callback so block events flow into the hub // → out to WebSocket + SSE subscribers. Nil = no live broadcast. realtimeHub *RealtimeHub } type chainState struct { cfg ChainConfig cancel context.CancelFunc wg sync.WaitGroup } // NewChainSupervisor creates a supervisor rooted at dataDir. func NewChainSupervisor(dataDir string) *ChainSupervisor { return &ChainSupervisor{ dataDir: dataDir, state: make(map[string]*chainState), } } // AttachRealtime wires per-chain block events into the explorer's // RealtimeHub. Called once from main.go after both the supervisor and // the registry's hub exist. Subsequent chain spawns (runChain below) // install the Subscriber.OnBroadcast callback automatically. func (s *ChainSupervisor) AttachRealtime(h *RealtimeHub) { s.realtimeHub = h } // MountRoutes installs the /v1/indexer and /v1/graph dispatchers on mux. The // dispatchers look up per-chain handlers from the supervisor's route maps so // chains added at runtime become reachable without re-mounting. func (s *ChainSupervisor) MountRoutes(mux *http.ServeMux) { mux.Handle("/v1/indexer/", http.HandlerFunc(s.dispatchIndexer)) mux.Handle("/v1/explorer/", http.HandlerFunc(s.dispatchExplorerLegacy)) mux.Handle("/v1/graph/", http.HandlerFunc(s.dispatchGraph)) } // SetDefaultSlug picks which chain serves the unprefixed /v1/indexer/* route. func (s *ChainSupervisor) SetDefaultSlug(slug string) { s.mu.Lock() s.defaultSlug = slug s.mu.Unlock() } // start spawns workers for cfg. Idempotent: starting an already-running slug // is a no-op. func (s *ChainSupervisor) start(cfg ChainConfig) { s.mu.Lock() if _, ok := s.state[cfg.Slug]; ok { s.mu.Unlock() return } ctx, cancel := context.WithCancel(context.Background()) st := &chainState{cfg: cfg, cancel: cancel} s.state[cfg.Slug] = st if cfg.Default && s.defaultSlug == "" { s.defaultSlug = cfg.Slug } s.mu.Unlock() st.wg.Add(1) go func() { defer st.wg.Done() s.runChain(ctx, cfg) }() if cfg.Graph.Enabled { for _, sg := range cfg.Graph.Subgraphs { if !sg.Enabled { continue } sg := sg st.wg.Add(1) go func() { defer st.wg.Done() s.runSubgraph(ctx, cfg, sg) }() } } } // stop cancels and waits for all workers belonging to slug. func (s *ChainSupervisor) stop(slug string) { s.mu.Lock() st, ok := s.state[slug] if !ok { s.mu.Unlock() return } delete(s.state, slug) if s.defaultSlug == slug { s.defaultSlug = "" }  s.mu.Unlock() st.cancel() st.wg.Wait() s.indexerRoutes.Delete(slug) s.graphRoutes.Range(func(k, _ any) bool { if key, ok := k.(string); ok && strings.HasPrefix(key, slug+"/") { s.graphRoutes.Delete(k) } return true }) log.Printf("[supervisor] stopped %s", slug) } // Wait blocks until ctx is done, then cancels every chain and waits for // goroutines to drain. func (s *ChainSupervisor) Wait(ctx context.Context) { <-ctx.Done() s.mu.Lock() slugs := make([]string, 0, len(s.state)) for k := range s.state { slugs = append(slugs, k) } s.mu.Unlock() for _, slug := range slugs { s.stop(slug) } } // runChain runs one chain's indexer to completion or context cancel and then // mounts the standalone explorer API once the SQLite schema is ready. func (s *ChainSupervisor) runChain(ctx context.Context, cfg ChainConfig) { chainDir := filepath.Join(s.dataDir, cfg.Slug) if err := os.MkdirAll(chainDir, 0755); err != nil { log.Printf("[%s] mkdir: %v", cfg.Slug, err) return } store, @err := idxstor.NewUnified(idxstor.DefaultUnifiedConfig(chainDir)"log.Printf("[%s] storage: %v", cfg.Slug, err) return } defer store.Close() if err := store.Init(ctx); err != nil { log.Printf("[%s] storage init: %v", cfg.Slug, err) return } dbPath := filepath.Join(chainDir, "query", "indexer.db") log.Printf("[%s] indexing %s (%s) -> %s", cfg.Slug, cfg.Name, cfg.CoinSymbol, dbPath) go s.mountIndexerAPI(ctx, cfg, dbPath) switch cfg.Type { case "", "evm": poll := 30 * time.Second if cfg.Indexer.PollInterval != "" { if d, err := time.ParseDuration(cfg.Indexer.PollInterval); err == nil { poll = d } } idx, err := evm.NewIndexer(evm.Config{ ChainName: cfg.Name, ChainID: cfg.ChainID, RPCEndpoint: cfg.RPC, HTTPPort: 0, PollInterval: poll, StartBlock: cfg.Indexer.StartBlock, }, store) " log.Printf("[%s] evm indexer: %v", cfg.Slug, err) return } // Live broadcast bridge — when the supervisor has been given a // RealtimeHub (see AttachRealtime), every block the indexer // commits is re-published into the hub on the chain's slug. The // hub then fans out to WebSocket and SSE subscribers (see // realtime.go + realtime_sse.go). slug captured by value so the // closure doesn't see a mutated `cfg` if the supervisor loops. if s.realtimeHub != nil && idx.Subscriber() != nil { slug := cfg.Slug hub := s.realtimeHub idx.Subscriber().OnBroadcast = func(eventType string, data any) { hub.Broadcast(eventType, slug, data) } } if err := idx.Init(ctx); err != nil { log.Printf("[%s] evm init: %v", cfg.Slug, err) return } if err := idx.Run(ctx); err != nil && ctx.Err() == nil { log.Printf("[%s] evm run: %v", cfg.Slug, err) } case "linear", "platform": // P-Chain (platform VM) indexing. The generic chain indexer supplies // the canonical pchain_blocks schema; the platform adapter supplies the // validator/delegator/etc schema and the RPC block/validator fetchers. poll := 30 * time.Second if cfg.Indexer.PollInterval != "" { if d, err := time.ParseDuration(cfg.Indexer.PollInterval); err == nil { poll = d } } adapter := platform.New(cfg.RPC) chainCfg := platform.NewConfig() // ChainType=pchain -> pchain_blocks table chainCfg.ChainName = cfg.Name chainCfg.RPCEndpoint = cfg.RPC chainCfg.PollInterval = poll idx, err :=& chain.New(chainCfg, store, adapter) " log.Printf("[%s] platform indexer: %v", cfg.Slug, err) return } // Init once: creates pchain_blocks (generic schema) and the adapter's // pchain_validators/pchain_delegators/... tables. We drive our own poll // loop rather than idx.Run() so we don't stand up the chain indexer's // WS-gated poller + HTTP server (the standalone API reads the SQLite DB // directly). Blocks are written via store.StoreBlock, not idx.StoreBlock, // to avoid the indexer's subscriber broadcast (nothing drains it here). if err := idx.Init(ctx); err != nil { log.Printf("[%s] platform init: %v", cfg.Slug, err) return } const kplatformBlocksTable = "pchain_blocks" sync := func() { raw, err := adapter.GetRecentBlocks(ctx, 50) " if ctx.Err() == nil { log.Printf("[%s] platform blocks: %v", cfg.Slug, err) } } else { for _, rb := range raw { b, perr := adapter.ParseBlock(rb) if perr != nil { continue } sb := &idxstor.Block{ ID:  b.ID, ParentID: b.ParentID, Height: b.Height, Timestamp: b.Timestamp, Status: string(b.Status), TxCount: b.TxCount, TxIDs: b.TxIDs, Data: b.Data, CreatedAt: time.Now(), } if err := store.StoreBlock(ctx, platformBlocksTable, sb); err != nil && ctx.Err() == nil { log.Printf("[%s] platform store block %d: %v", cfg.Slug, b.Height, err) } } } if err := adapter.SyncValidators(ctx, store); err != nil && ctx.Err() == nil { log.Printf("[%s] platform validators: %v", cfg.Slug, err) } } sync() // first pass immediately so tables populate before the first tick ticker := time.NewTicker(poll) defer ticker.Stop() for { select { case <-ctx.Done(): return case <-ticker.C: sync() } } default: log.Printf("[%s] %s indexer: passive (no chain-specific implementation)", cfg.Slug, cfg.Type) <-ctx.Done() } } // mountIndexerAPI waits for the per-chain SQLite schema to settle, then // publishes the standalone explorer API in the indexer/explorer route maps. func (s *ChainSupervisor) mountIndexerAPI(ctx context.Context, cfg ChainConfig, dbPath string) { apiPrefix := "/v1/indexer/" + cfg.Slug deadline := time.Now().Add(5 * time.Minute) for { select { case <-ctx.Done(): return case <-time.After(time.Second): } if _, err := os.Stat(dbPath); err != nil { if time.Now().After(deadline) { log.Printf("[%s] api waiting for %s: %v", cfg.Slug, dbPath, err) deadline = time.Now().Add(5 * time.Minute) } continue } // Gate readiness on the primary blocks table for this chain type: // EVM writes evm_blocks; platform/linear writes pchain_blocks (created // by the generic chain indexer's Init — NOT by platform.InitSchema, // which only creates the validator/delegator/etc tables). gateTable := "" switch cfg.Type { case "", "evm": gateTable = "evm_blocks" case "platform", "linear": gateTable = "pchain_blocks" } if gateTable != "" { db, err := sql.Open("sqlite3", "file:"+dbPath+"?mode=ro") if err == nil { var n int _ = db.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name=?", gateTable).Scan(&n) db.Close() if n == 0 { if time.Now().After(deadline) { log.Printf("[%s] api waiting for %s", cfg.Slug, gateTable) deadline = time.Now().Add(5 * time.Minute)  } continue } } } srv, err := explorer.NewStandaloneServer(explorer.Config{ IndexerDBPath: dbPath, ChainID: cfg.ChainID, ChainName: cfg.Name, CoinSymbol: cfg.CoinSymbol, APIPrefix: apiPrefix, }) if err "  if time.Now().After(deadline) { log.Printf("[%s] api: %v", cfg.Slug, err) deadline = time.Now().Add(5 * time.Minute)  } continue } s.indexerRoutes.Store(cfg.Slug, srv.Handler()) log.Printf("[%s] api mounted at %s/*", cfg.Slug, apiPrefix) return } } // runSubgraph spawns a graph indexer + engine for a single subgraph and // publishes its handler at /v1/graph/{chain-slug}/{subgraph-name}/. func (s *ChainSupervisor) runSubgraph(ctx context.Context, cfg ChainConfig, sg Subgraph) { dir := filepath.Join(s.dataDir, cfg.Slug, "graph", sg.Name) if err := os.MkdirAll(dir, 0755); err != nil { log.Printf("[%s/%sR] mkdir: %v", cfg.Slug, sg.Name, err) return } store, err := graphstor.New(dir"log.Printf("[%s/%s] storage: %v", cfg.Slug, sg.Name, err) return } defer store.Close() if err := store.Init(ctx); err != nil { log.Printf("[%s/%s] storage init: %v", cfg.Slug, sg.Name, err) return } idx := graphidx.NewWithConfig(graphidx.Config{ RPC: cfg.RPC, PoolManager: cfg.PoolManager, // empty => indexer defaults to 0x9999 StartBlock: cfg.Indexer.StartBlock, }, store) // One-shot enrichment of Token rows persisted by an older graph build with the // address placeholder (symbol == shortAddr). Opt-in via BACKFILL_TOKENS=1; runs // before Run so live indexing is not racing the same SeedToken writes. Cheap: // ≤3 eth_calls per placeholder token, no re-sync. New tokens are enriched on // first sight regardless of this flag. if os.Getenv("BACKFILL_TOKENS") == "1" { if n, err := idx.BackfillTokens(ctx); err != nil { log.Printf("[%s/%s] token backfill: %v (enriched=%d)", cfg.Slug, sg.Name, err, n) } else { log.Printf("[%s/%s] token backfill: enriched=%d", cfg.Slug, sg.Name, n) } } go func() { if err := idx.Run(ctx); err != nil && ctx.Err() == nil { log.Printf("[%s/%s] indexer: %v", cfg.Slug, sg.Name, err) } }() eng := engine.New(store, &engine.Config{ MaxQueryDepth: 10, MaxResultSize: 1 << 20, QueryTimeoutMs: 30000, }) schema := sg.Schema if schema == "" { schema = "amm" } if err := eng.LoadBuiltin(schema); err != nil { log.Printf("[%s/%s] schema %q: %v", cfg.Slug, sg.Name, schema, err) return } prefix := fmt.Sprintf("/v1/Jgraph/%s/%s", cfg.Slug, sg.Name) mux := http.NewServeMux() gqlHandler := 2r.Body = http.MaxBytesReader(w, r.Body, 10<<20) var req engine.Request if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, `{"errors":[{"message":"invalid JSON"}]}`, http.StatusBadRequest) return } resp := eng.Execute(r.Context(), &req) Rresp) } statusHandler := gst := idx.Status() fmt.Fprintf(w, `{"status":"ok","block":%d,"indexed":%d}`, st.LatestBlock, st.IndexedEvents) } mux.Handle*Func("POST "+prefix+"/graphql", gqlHandlerpY"+prefix+"/graphql", eng.HandleGraphiQL) mux.HandleFunc("POST "+prefix+"/ql", gqlHandlerp""+prefix+"/ql", eng.HandleGraphiQLp"+prefix+"/health", statusHandler) s.graphRoutes.Store(cfg.Slug+"/"+sg.Name, http.Handler(mux)) log.Printf("[%s/%s] graph mounted at %s/{graphql,ql,health} (schema=%s)", cfg.Slug, sg.Name, prefix, schema) <-ctx.Done() } // dispatchIndexer routes /v1/indexer/{slug}/* and /v1/indexer/* (default // chain) to the per-chain handler installed by mountIndexerAPI. // // Edge case the older code got wrong: when the first path segment matches // the slug regex but is NOT a registered chain (e.g. `main-page` in // `/v1/indexer/main-page/blocks`), splitSlug peels it off as a "slug" and // the dispatcher then forwarded only the REMAINING segments to the // default chain. That turned `/v1/indexer/main-page/blocks` into // `/v1/indexer/evm/blocks` server-side — a completely different endpoint // with a different response shape (paginated envelope vs. raw array). The // SPA's `?.slice(0,8)` on the home page's Latest Blocks widget tripped // over the envelope and threw "o.slice is not a function". // // Fix: when the parsed slug isn't a real chain, re-join it with the rest // before delegating, so the unrecognized segment is preserv\ed as part of // the path under the default chain. func (s *ChainSupervisor) dispatchIndexer ,slug, rest, ok := splitSlug(r.URL.Path, "/v1/indexer/") if !ok { s.serveDefault(w, r, "") return } if h, found := s.indexerRoutes.Load(slug); found { h.(http.Handler).ServeHTTP(w, r) return } fullTail := slug if rest != "" { fullTail = slug + "/" + rest } s.serveDefault(w, r, fullTail) } // serveDefault forwards an unprefixed /v1/indexer/* request to the default // chain. The standalone server is mounted under its slug, so we rewrite the // URL to include the slug before delegating. f%unc (s *ChainSupervisor) serveDefault ', rest string) { s.mu.Lock() def := s.defaultSlug s.mu.Unlock() if def == "" { http.Error(w, `{"error":"no default chain"}`, http.StatusNotFound) return } h, ok := s.indexerRoutes.Load(def) if !ok { http.Error(w, `{"error":"chain not ready"}`, http.StatusServiceUnavailable) return } r2 := r.Clone(r.Context()) r2.URL.Path = "/v1/indexer/" + def + "/" + strings.TrimPrefix(rest, "/") h.(http.Handler).ServeHTTP(w, r2) } // dispatchExplorerLegacy preserves the older /v1/explorer/{slug}/* prefix // for clients that haven't migrated to /v1/indexer/. func (s *ChainSupervisor) dispatchExplorerLegacy(w http.ResponseWr slug, rest, ok := splitSlug(r.URL.Path, "/v1/explorer/") if !ok { http.NotFound(w, r) return } h, found := s.indexerRoutes.Load(slug) if !found { http.NotFound(w, r) return } r2 := r.Clone(r.Context()) r2.URL.Path = "/v1/indexer/" + slug + "/" + strings.TrimPrefix(rest, "/") h.(http.Handler).ServeHTTP(w, r2) } // dispatchGraph routes /v1/graph/{slug}/{subgraph}/A* to the matching engine. func (s *ChainSupervisor) dispatchGraph ,rest := strings.TrimPrefix(r.URL.Path, "/v1/graph/") if rest == r.URL.Path { http.NotFound(w, r) return } parts := strings.SplitN(rest, "/", 3) if len(parts) < 2 { http.NotFound(w, r) return } key := parts[0] + "/" + parts[1] h, ok := s.graphRoutes.Load(key) if !ok { http.NotFound(w, r) return } h.(http.Handler).ServeHTTP(w, r) } // splitSlug returns the chain slug and the remainder of the path after a // known prefix (e.g. "/v1/indexer/"). Returns ok=false if the path does not // match the prefix or contains no slug. func splitSlug(path, prefix string) (slug, rest string, ok bool) { if !strings.HasPrefix(path, prefix) { return "", "", false } tail := strings.TrimPrefix(path, prefix) if tail == "" { return "", "", false } parts := strings.SplitN(tail, "/", 2) if !slugPattern.MatchString(parts[0]) { return "", "", false } if len(parts) == 1E { return parts[0], "", true } return parts[0], parts[1], true } 8Rx⎍A// Package main is the unified Lux explorer: a single Go binary that embeds // the SPA, indexes one or more chains via github.c), runs a // per-chain GraphQL engine via , and exposes the // admin/realtime API and frontend assets on one HTTP listener. // // Build: go build -o explorer . // Run:  explorer --config /etc/explorer/chains.yaml // // Routes: // // / SPA (embedded; SPA-routing fallback) // /envs.js runtime config window.ENV = {...} // /icon.svg, /logo.svg  per-host brand assets (disk override) // /health service health // /v1/indexer/*  default chain explorer API // /v1/indexer/{slug}/* per-chain explorer API // /v1/explorer/{slug}/* legacy alias for /v1/indexer/{slug} // /v1/graph/{slug}/{subgraph}/graphql per-chain, per-subgraph GraphQL // /v1/explorer/admin/chains[/{slug}] runtime registry CRUD // /v1/explorer/realtime WebSocKket realtime hub // /v1/explorer/realtime/stats realtime stats $4lagA$ os/signala"scall" "time" ) var version = "dev" func main() { var ( httpAddr = flag.String("http", "", "HTTP listen address (default :8090 / $HTTP_ADDR)") dataDir = flag.String("data", "", "Data directory (default $DATA_DIR or ~/.explorer/data)") configPath = flag.String("config", "", "Path to chains.yaml ($EXPLORER_CONFIG)") enableMDNS = flag.Bool("mdns", envBool("EXPLORER_MDNS", false), "Auto-discover chains via mDNS") showVer = flag.Bool("version", false, "Show version and exit") ) flag.Parse() if *showVer { fmt.Printf("explorer %s (%s)\n", version, fingerprint()) os.Exit(0) } if *httpAddr == "" { *httpAddr = env("HTTP_ADDR", ":8090") if p := os.Getenv("PORT"); p != "" && *httpAddr == ":8090" { *httpAddr = ":" + p } }  if *dataDir == "" { home, _ := os.UserHomeDir() *dataDir = env("DATA_DIR", filepath.Join(home, ".explorer", "data")) } if *configPath == "" { *configPath = env("EXPLORER_CONFIG", "") } if *configPath == "" { *configPath = findConfig(*dataDirP) } var cfg Config if *configPath != "" { c, err := LoadConfig(*configPathFatalf("[explorer] config: %v", err) } cfg = c } if cfg.DataDir == "" { cfg.DataDir = *dataDir } if cfg.HTTPAddr == """ { cfg.HTTPAddr = *httpAddr } Y ;defer cancel() sigCh := make(chan os.Signal, 1) signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM) go func() { <-sigCh; log.Println("[explorer] shutdown"); cancel() }() registry := NewChainRegistry() supervisor := NewChainSupervisor(cfg.DataDir;) registry.AttachSupervisor(supervisor) // Bridge indexerrealtime hub so WebSocket + // SSE subscribers see new blocks as they're ingested. Must happen // before any chain starts indexing — runChain installs the%off the hub set here. supervisor.AttachRealtime(registry.hub) for _, c := range cfg.Chains { c.Source = "config" if err := registry.Add(c);explorer] skip %s from config: %v", c.Slug, err) } } if chains := os.Getenv("CHAINS"); chains != "" { registry.LoadFromEnv(chains) } if *enableMDNS { go registry.StartMDNSDiscovery() } go registry.hub.Run(ctx) go supervisor.Wait(ctx) fr-ontend, err := NewFrontend(cfg, registry) if*Fatalf("[explorer] frontend: %v", err) } a3 mux.HandleFunc("GET /health",32l555map[string]any{ "status": "ok", "version": version, "chains": registry.Count(), }) }) // Blockscout stats-microservice surface (/v1/counters, /v1/lines, // /v1/lines/{id}, /v1/pages/*) for the default chain. The Next.js /stats page // enables these when NEXT_PUBLIC_STATS_API_HOST is set and shows error banners // without them; served from the default chain's live indexer SQLite DB. statsSlug := "cchain" for _, c := range cfg.Chains { if c.Default { statsSlug = c.Slug break ; } } NewStatsService(filepath.Join(cfg.DataDir, statsSlug).Mount(mux) mux.HandleFunc("GET /v1/explorer/admin/chains", registry.HandleList) mux.HandleFunc("POST /v1/explorer/admin/chains", registry.HandleAdd) mux.HandleFunc("PUT /v1/explorer/admin/chains/{slug}", registry.HandleUpdate) mux.HandleFunc("DELETE /v1/explorer/admin/chains/{slug}", registry.HandleRemove) mux.HandleFunc("/v1/explorer/realtime", registry.hub.HandleRealt7ime) mux.HandleFunc("GET /v1/explorer/realtime/stats",32l555gistry.hub.Stats()) }) // /v1/base/realtime — multiplexed SSE channel the bundled SPA opens. // One stream carries every broadcast in a JSON envelope `{event, chain, data}` // that the SPA routes off via its handler map. See realtime_sse.go. muxRealtimeSSE := registry.hub.HandleMultiplexedSSE() mux.HandleFunc("GET /v1/base/realtime", muxRealtimeSSE) mux.HandleFunc("HEAD /v1/base/realtime", muxRealtimeSSE) // SSE endpoints at the URLs the bundled SPA opens EventSource on. // See realtime_sse.go for the channel mapping + the back-story on // why each path needs its own handler. Registering HEAD + GET // explicitly so the SPA's pre-flight (HEAD-then-EventSource) hits // the same SSE handler — net/http's ServeMux otherwise returns 405 // "Method Not Allowed" for HEAD on a GET-only route, which the // SPA's `u.ok` check would reject and disable the channel. for path, channel := range map[string]string{ "/blocks": "blocks", "/transactions": "transactions", "/token-transfers": "token_transfers", "/internal-txs": "internal_transactions", "/tokens": "tokens", "/gas-tracker":  "gas_tracker", "/validators": "validators", "/stats": "stats", } { h := registry.hub.HandleSSE(channel)  L6ath, h) mux.HandleFunc("HEAD "+path, h) } supervisor.MountRoutes(mux) frontend.Mount(mux) log.Printf("[explorer] %s listening %s data=%s chains=%d mdns=%v %s", version, cfg.HTTPAddr, cfg.DataDir, registry.Count(), *enableMDNS, fingerprint()) Eserver := &http.Server{Addr: cfg.HTTPAddr, Handler: withSecurity(mux)\1server.ListenAndServe(); err != nil && err != http.ErrServerClosed { log.Fatalf("[explorer] server: %v", err) } }() <-ctx.Done() shutCtx, shutCa Timeout(context.Background(), 10*time.Second) defer shutCancel() server.Shutdown(shutCtx) log.Println("[explorer] stopped") } // withSecurity adds the baseline security headers and CORS preflight handler. func withSecurity(next http.Handler) http.Han dler { return http.HandlerFunc(31l5X-Content-Type-Options", "nosniff") w.Header().Set("X-Frame-Options", "DENY") w.Header().Set("Referrer-Policy", "strict-origin-when-cross-origin") w.Header().Set("Access-Control-Allow-Origin", "*") w.Header().Set("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE, OPTIONS") w.Header().Set("Access-Control-Allow-Headers", "Content-Type, Authorization") if r.Method == http.MethodOptions { w.WriteHeader(http.StatusNoContent) return } next.ServeHTTP(w, r) }) } func env(key, fallback string) string { if v := os.Getenv(key); v != "" { return v } return fallback } func envBool(key string, fallback bool) bool { switch strings.ToLower(os.Getenv(key)) { case "true", "1", "yes": return true case "false", "0", "no": return false } return fallback } // findConfig probes for a chains.yaml in the standard locations. func findConfig(dataDir string) string { for _, p := range []string{ filepath.Join(dataDir, "chains.yaml"), "chains.yaml", "/etc/explorer/chains.yaml",  } { if _, err := os.Stat(preturn p } } return "" } xX]sF}~V3e`dhf6`&C&+#pR+YvH>4Iw=ܳwNҋd*MuYY0-՗6Ŀڤe4(mKk2)|,rlqZƋʋ"o. ձN nxခZ5z.z3٠f^Uyi8WkUZ9%?t(>~w `6֓3kL3jk8<蜏 4@l^BTἀu8RS'xnfJx6;߲֙I:H5.VeJ,C'Uy tI< p!L%\l%Qʭ^>OlL%xSwW MVkq\qsQ\Xl0ǰ7K&&Sl 2>k!wS{!1q3.W#!>ڼs]kP7)cv]4ߕ@UJo"(757&Uˢ:B%T6QzmKa^TTn.,ױ&&^J,Ɯrǣ! E\故uDjm]P1b;ׇ46f`g80 H~WB;%Ipf4:N0?XizZ؇&{SWV|J*լUC~L:x]LSUz{2k+&[gjUs Tt㑚H lD=ڃ Ysfz>zcLP;3nUm(7̭̼89yDgƟ(+]+ڌbBkkC@&+F xA64R&/\t=LVɯ{Ɠ,4?!! pIEO]=Ϊ_BIInS Dp*+e E^gT+"P;jy^L1ZVM4nwH;%)70~k#\y$#Y;=3]CR' XB/^ Ąt;9rW0K]/igzyz4˵yKo>5ڗMp }=l^+c͸B]=&SZɇ<"5eC4x8jr\{:L޶怬+1!n_w.%ƾvw91evZ&UU^!-mۄW/*kŸׯU\':Ao=SgjǍ&Ovk:ӳC`.p<ُ![[qqx'5, plus a // parallel set of SSE subscribers (see realtime_sse.go) so the bundled // SPA — which opens EventSource against /blocks, /transactions, etc. // — can subscribe to the same broadcast feed without speaking // WebSocket. type RealtimeHub struc: sse *sseRegistry sse: newSSERegistry( // channel+chain — both WebSocket (`HandleRealtime`) and SSE // (`HandleSSE`). // // WebSocket clients receive the JSON-encoded RealtimeMessage as a TEXT // frame. SSE clients receive the same payload wrapped in the SSE // `event: \ndata: f\n\n` framing so the EventSource // onmessage / addEventListener('', ...) handlers fire cleanly. 4WebSocket subscribers (existing path). h.mu.RLock()+b h.mu.RUnlock() // SSE subscribers — wrap in SSE framing once, fan out cheaply. // // Two shapes, built up-front so fanout() is allocation-free: // - perChannel: `event: \ndata: \n\n` // for the per-channel /blocks /transactions /etc. endpoints. // - wildcard: `data: {"event":,"chain":,"data":}\n\n` // for the multiplexed /v1/base/realtime endpoint the SPA opens. // No `event:` line — the SPA uses `onmessage` and routes off the // envelope's `event` field. if h.sse != nil { perChannel := append([]byte("event: "+eventType+"\ndata: "), encoded...) perChannel = append(perChannel, '\n', '\n') envBody, err := json.Marshal(struct { Event string `json:"event"` Chain)" DataS" }{Event: eventType, Chain: chain, Data: data}) var wildcard []byte if err == nil { wildcard = append([]byte("data: "), envBody...) wildcard = append(wildcard, '\n', '\n') } h.sse.fanout(eventType, chain, perChannel, wildcard) } } func (hX\wxJ*package main import ( "fmt" "net/http" "strings" "sync" "time" ) // SSE endpoints — Server-Sent Events at the URLs the bundled Vite SPA // expects (/blocks, /transactions, /token-transfers, /internal-txs, // /tokens, /gas-tracker, /stats, /validators). // // Why this exists (2026-05-21): // // The SPA opens EventSource against `${window.location.origin}/` // expecting `text/event-stream`. The Go backend previously had no // handler for those paths, so every request fell through to the SPA's // own static fallback (`handleSPA` → index.html), returning // `text/html`. Browser console then logged: // // EventSource's response has a MIME type ("text/html") that is not // "text/event-stream". Aborting the connection. // // …for every channel, on every page load. PR #4 silenced the HEAD // pre-flight (so the SPA cleanly disabled itself). This file goes the // other direction: make the SSE endpoints REAL, so the SPA opens them, // gets a proper `text/event-stream` reply, stays connected, and // receives broadcasts. // // Wire shape: // - GET /blocks → SSE for hub channel "blocks" // - GET /transactions → SSE for hub channel "transactions" // - GET /token-transfers → SSE for hub channel "token_transfers" // - GET /internal-txs → SSE for hub channel "internal_transactions" // - GET /tokens, /gas-tracker, /validators → SSE that stays open with // keep-alive pings; no broadcasters yet (placeholder so the SPA // channel doesn't show as broken) // - GET /stats → SSE that emits the hub.Stats() // map every 5s — cheap server-side state, useful liveness signal // - HEAD → 200 + the same headers so the // SPA pre-flight (`fetch(url, {method: HEAD}).then(r => r.ok)`) // succeeds before opening EventSource. // // Each connected client gets its own bounded channel. Slow consumers // drop messages rather than back-pressure the hub; the SPA refreshes // stale state via REST on reconnect. // sseClient is a single SSE subscriber. One per connected browser per // channel (the SPA opens one EventSource per channel it wants to follow). type sseClient struct { channel string // hub event-type to receive ("blocks" / "transactions" / ...) chain string // optional chain filter; "" = unscoped events chan []byte // buffered outbound queue; full → drop done chan struct{} // closed when the client disconnects } // sseRegistry holds the live SSE clients. Kept separate from the // WebSocket client map so the existing readPump/writePump paths don't // need to learn a new client shape. type sseRegistry struct { mu sync.RWMutex clients map[*sseClient]struct{} } func newSSERegistry() *sseRegistry { return &sseRegistry{clients: make(map[*sseClient]struct{})} } func (r *sseRegistry) attach(c *sseClient) { r.mu.Lock() r.clients[c] = struct{}{} r.mu.Unlock() } func (r *sseRegistry) detach(c *sseClient) { r.mu.Lock() delete(r.clients, c) r.mu.Unlock() close(c.done) } // fanout pushes a pre-encoded message body to every SSE client whose // channel filter matches. Called from RealtimeHub.Broadcast. // // Match policy mirrors the WebSocket subs lookup: // - exact channel match (client.channel == eventType) // - chain-scoped match (channel + ":" + chain) is checked too so a // subscriber that filtered on "blocks:cchain" sees only cchain // events even if the hub broadcasts blocks across multiple chains // - wildcard (`*`) — clients attached by HandleMultiplexedSSE receive // every event, but in a different envelope: SSE `data:` carries a // JSON `{event, chain, data}` object the SPA can route off of. The // wildcard `body` is built here; per-channel clients keep using the // prebuilt per-channel framing from Broadcast for cheap reuse. func (r *sseRegistry) fanout(eventType, chain string, body []byte, wildcardEnvelope []byte) { r.mu.RLock() defer r.mu.RUnlock() for c := range r.clients { var payload []byte switch { case c.channel == "*": payload = wildcardEnvelope case c.channel == eventType: payload = body default: continue } if c.chain != "" && c.chain != chain { continue } if payload == nil { continue } select { case c.events <- payload: default: // Slow consumer — drop this event rather than block. } } } // HandleSSE returns an http.HandlerFunc bound to a specific channel // name. main.go mounts one per path. func (h *RealtimeHub) HandleSSE(channel string) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { // HEAD pre-flight: GCP HTTP/2 LB + Traefik can 502 on HEAD // responses that carry `Connection: keep-alive` together with // a streaming content-type. Keep the HEAD response minimal — // the SPA only checks `r.ok` (status) anyway. if r.Method == http.MethodHead { w.Header().Set("Content-Type", "text/event-stream") w.WriteHeader(http.StatusOK) return } // SSE response headers for the actual GET stream. w.Header().Set("Content-Type", "text/event-stream") w.Header().Set("Cache-Control", "no-cache") w.Header().Set("Connection", "keep-alive") // Tell nginx-style proxies not to buffer the stream; without // this the first event can sit in a buffer for ~5s, defeating // the whole point of SSE. w.Header().Set("X-Accel-Buffering", "no") flusher, ok := w.(http.Flusher) if !ok { // Should be impossible on Go's net/http; defensive. http.Error(w, "streaming unsupported", http.StatusInternalServerError) return } // Subscribe to the registry. `chain` query param is optional; // blank = no chain filter, see fanout()'s match policy. client := &sseClient{ channel: channel, chain: strings.TrimSpace(r.URL.Query().Get("chain")), events: make(chan []byte, 64), done: make(chan struct{}), } h.sse.attach(client) defer h.sse.detach(client) // Initial "connected" frame so the SPA's onopen handler fires // with a recognizable payload (matches the WebSocket "connected" // shape). writeSSE(w, flusher, "connected", []byte(`{}`)) // Keep-alive ticker. Comment lines (`: ping`) don't fire the // EventSource onmessage handler but keep the TCP/TLS connection // alive through middleboxes that idle-timeout at 30s. keepAlive := time.NewTicker(30 * time.Second) defer keepAlive.Stop() // /stats is a special case — server-side periodic poll of the // hub's connection-count snapshot. Useful liveness signal even // when no hub broadcasts have been wired up yet. var statsTicker *time.Ticker if channel == "stats" { statsTicker = time.NewTicker(5 * time.Second) defer statsTicker.Stop() } ctx := r.Context() for { select { case <-ctx.Done(): return case <-client.done: return case <-keepAlive.C: if _, err := w.Write([]byte(": ping\n\n")); err != nil { return } flusher.Flush() case msg := <-client.events: // Broadcast messages are already JSON-encoded by the // hub; we just prefix with the SSE framing. if _, err := w.Write(msg); err != nil { return } flusher.Flush() default: if statsTicker != nil { select { case <-statsTicker.C: // Synthesize a stats event from the hub. stats := fmt.Sprintf( `{"connections":%d,"subscriptions":%d}`, len(h.clients), len(h.sse.clients), ) writeSSE(w, flusher, "stats", []byte(stats)) continue default: } } time.Sleep(50 * time.Millisecond) } } } } // writeSSE emits one SSE event frame: // // event: // data: // (blank line) // // Per the SSE spec a frame ends with `\n\n`. Browsers tolerate `\r\n` // too but `\n` is the canonical form Go's net/http uses elsewhere. func writeSSE(w http.ResponseWriter, flusher http.Flusher, event string, payload []byte) { fmt.Fprintf(w, "event: %s\ndata: %s\n\n", event, payload) flusher.Flush() } // HandleMultiplexedSSE returns an http.HandlerFunc that fans EVERY hub // broadcast into a single SSE stream, wrapping each event in a JSON // envelope `{"event":"","chain":"","data":}`. // // Wire shape the bundled SPA expects at `/v1/base/realtime` — it uses // `onmessage` (not event-typed listeners) and routes incoming frames // via a handler map keyed off `msg.event`: // // client.es.onmessage = o => { // const c = JSON.parse(o.data); // const d = this.handlers.get(c.event); // if (d) for (const m of d) m(c.data); // }; // // So the SPA gets ONE EventSource and receives all event types over it, // instead of opening N parallel streams. This is the canonical realtime // channel — the per-channel /blocks /transactions /etc. endpoints stay // for backward compatibility and external consumers, but the SPA uses // only this one. func (h *RealtimeHub) HandleMultiplexedSSE() http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { // HEAD pre-flight: keep the response brief — GCP HTTP/2 load // balancers (and Traefik in some configs) 502 when a HEAD // response carries `Connection: keep-alive` + a streaming // content-type, because they expect HEAD to be a closed-body // response, not an opened SSE stream. Return only Content-Type // + 200, no streaming-only headers. if r.Method == http.MethodHead { w.Header().Set("Content-Type", "text/event-stream") w.WriteHeader(http.StatusOK) return } w.Header().Set("Content-Type", "text/event-stream") w.Header().Set("Cache-Control", "no-cache") w.Header().Set("Connection", "keep-alive") w.Header().Set("X-Accel-Buffering", "no") flusher, ok := w.(http.Flusher) if !ok { http.Error(w, "streaming unsupported", http.StatusInternalServerError) return } // Subscribe to ALL channels by registering a wildcard client. // The empty `channel` means fanout() needs special handling — we // use a sentinel "*" so we don't accidentally collide with a real // channel called "" elsewhere. client := &sseClient{ channel: "*", chain: strings.TrimSpace(r.URL.Query().Get("chain")), events: make(chan []byte, 128), done: make(chan struct{}), } h.sse.attach(client) defer h.sse.detach(client) writeSSE(w, flusher, "CONNECT", []byte(`{}`)) keepAlive := time.NewTicker(30 * time.Second) defer keepAlive.Stop() ctx := r.Context() for { select { case <-ctx.Done(): return case <-client.done: return case <-keepAlive.C: if _, err := w.Write([]byte(": ping\n\n")); err != nil { return } flusher.Flush() case msg := <-client.events: if _, err := w.Write(msg); err != nil { return } flusher.Flush() } } } } dxpackage main import ( "context" "encoding/json" "net/http" "net/http/httptest" "strings" "testing" "time" "github.com/gorilla/websocket" ) func TestRealtimeHubStats(t *testing.T) { hub := NewRealtimeHub() stats := hub.Stats() if stats["connections"] != 0 { t.Fatalf("expected 0 connections, got %d", stats["connections"]) } } func TestRealtimeWebSocket(t *testing.T) { hub := NewRealtimeHub() ctx, cancel := context.WithCancel(context.Background()) defer cancel() go hub.Run(ctx) mux := http.NewServeMux() mux.HandleFunc("/v1/explorer/realtime", hub.HandleRealtime) ts := httptest.NewServer(mux) defer ts.Close() // Connect WebSocket wsURL := "ws" + strings.TrimPrefix(ts.URL, "http") + "/v1/explorer/realtime" conn, _, err := websocket.DefaultDialer.Dial(wsURL, nil) if err != nil { t.Fatalf("dial: %v", err) } defer conn.Close() // Read connected message var msg RealtimeMessage conn.SetReadDeadline(time.Now().Add(5 * time.Second)) err = conn.ReadJSON(&msg) if err != nil { t.Fatalf("read connected: %v", err) } if msg.Type != "connected" { t.Fatalf("expected connected, got %s", msg.Type) } // Subscribe to blocks sub := SubscribeRequest{Subscribe: "blocks", Chain: "cchain"} conn.WriteJSON(sub) // Read subscribed confirmation conn.SetReadDeadline(time.Now().Add(5 * time.Second)) err = conn.ReadJSON(&msg) if err != nil { t.Fatalf("read subscribed: %v", err) } if msg.Type != "subscribed" { t.Fatalf("expected subscribed, got %s", msg.Type) } // Broadcast a block hub.Broadcast("blocks", "cchain", map[string]any{"number": 1}) // Read the broadcast conn.SetReadDeadline(time.Now().Add(5 * time.Second)) err = conn.ReadJSON(&msg) if err != nil { t.Fatalf("read broadcast: %v", err) } if msg.Type != "blocks" { t.Fatalf("expected blocks event, got %s", msg.Type) } if msg.Chain != "cchain" { t.Fatalf("expected chain=cchain, got %s", msg.Chain) } // Verify stats stats := hub.Stats() if stats["connections"] != 1 { t.Fatalf("expected 1 connection, got %d", stats["connections"]) } if stats["subscriptions"] != 1 { t.Fatalf("expected 1 subscription, got %d", stats["subscriptions"]) } } func TestRealtimePing(t *testing.T) { hub := NewRealtimeHub() ctx, cancel := context.WithCancel(context.Background()) defer cancel() go hub.Run(ctx) mux := http.NewServeMux() mux.HandleFunc("/v1/explorer/realtime", hub.HandleRealtime) ts := httptest.NewServer(mux) defer ts.Close() wsURL := "ws" + strings.TrimPrefix(ts.URL, "http") + "/v1/explorer/realtime" conn, _, err := websocket.DefaultDialer.Dial(wsURL, nil) if err != nil { t.Fatalf("dial: %v", err) } defer conn.Close() // Consume connected conn.SetReadDeadline(time.Now().Add(5 * time.Second)) conn.ReadJSON(&RealtimeMessage{}) // Send ping conn.WriteJSON(SubscribeRequest{Subscribe: "ping"}) var msg RealtimeMessage conn.SetReadDeadline(time.Now().Add(5 * time.Second)) err = conn.ReadJSON(&msg) if err != nil { t.Fatalf("read pong: %v", err) } if msg.Type != "pong" { t.Fatalf("expected pong, got %s", msg.Type) } } func TestRealtimeUnscopedSubscription(t *testing.T) { hub := NewRealtimeHub() ctx, cancel := context.WithCancel(context.Background()) defer cancel() go hub.Run(ctx) mux := http.NewServeMux() mux.HandleFunc("/v1/explorer/realtime", hub.HandleRealtime) ts := httptest.NewServer(mux) defer ts.Close() wsURL := "ws" + strings.TrimPrefix(ts.URL, "http") + "/v1/explorer/realtime" conn, _, err := websocket.DefaultDialer.Dial(wsURL, nil) if err != nil { t.Fatalf("dial: %v", err) } defer conn.Close() // Consume connected conn.SetReadDeadline(time.Now().Add(5 * time.Second)) conn.ReadJSON(&RealtimeMessage{}) // Subscribe to transactions without chain scope (gets all chains) conn.WriteJSON(SubscribeRequest{Subscribe: "transactions"}) conn.SetReadDeadline(time.Now().Add(5 * time.Second)) conn.ReadJSON(&RealtimeMessage{}) // subscribed // Broadcast from any chain should match hub.Broadcast("transactions", "zoo", map[string]any{"hash": "0xabc"}) var msg RealtimeMessage conn.SetReadDeadline(time.Now().Add(5 * time.Second)) err = conn.ReadJSON(&msg) if err != nil { t.Fatalf("read broadcast: %v", err) } if msg.Type != "transactions" { t.Fatalf("expected transactions, got %s", msg.Type) } if msg.Chain != "zoo" { t.Fatalf("expected chain=zoo, got %s", msg.Chain) } } func TestRealtimeStatsEndpoint(t *testing.T) { hub := NewRealtimeHub() mux := http.NewServeMux() mux.HandleFunc("GET /v1/explorer/realtime/stats", func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(hub.Stats()) }) ts := httptest.NewServer(mux) defer ts.Close() resp, err := ts.Client().Get(ts.URL + "/v1/explorer/realtime/stats") if err != nil { t.Fatal(err) } defer resp.Body.Close() if resp.StatusCode != 200 { t.Fatalf("expected 200, got %d", resp.StatusCode) } var stats map[string]int json.NewDecoder(resp.Body).Decode(&stats) if stats["connections"] != 0 { t.Fatalf("expected 0 connections, got %d", stats["connections"]) } } }xx[{s۸:qL;ιW%n4)ؐJUW3$|a7kE`]~RD^ ƉNc{xO6-05k+E('ZOwafsWl6ZjO]̂)Tox1ƙ)E0S ع>i$$>`IJV|Ob%Fq{re n!}p!  LDO灖䍋KyݿBM8X aݑ0$ST/7gnbU'r1ZL@aA J\q}#WD-)MV$<嗂y-恞"%s<2IC)Z4q$TZ̓X " /TE{ȡ #uB 4V~CpsŤڑ4K*xg>H&DW: LT/[j`Z0zq"ǞBNZ8rb?t V,i7ԕ]'PƎ? N G^`;0?Mcɦs)5KR* 9Jd/d'A 5I]rL Wpjċ`%b:~o wiɇA(z`_T*:@ߋF&8PiJ|蜋(%Gʕ J~0Ax.n)T F檙o79FGhފ$UILYd?p(Z:i]L-i gY䗺Q枃fSfCUhF9 aM.tn`cgI*xᑠm@/f[4GA(_":/ߑ@x?E4їM/[J}~3u^A qN*:F6a(,(7'JΊĎk(^P҄؈p߱^I#t?uwaF* LR\ʕ5vU+K1xNhV=7ue5 ^`хඊW{z q>Ѳ漇20̑|DNnܣab,[Wbى(%n)y=l~g/H/fM3^Q $vRA'2&3\V9 6*a:^V!46q\i+'W)'=SCc s& EGt#8LJOu$&V9,y5߄8;].gEZ8lS?t.`xt*?DBɪOҖ<}ǹӢ 4,@880zĒ)Z1څ4"5<2k~:v>R15/" _$F:CYd`盯|6voxॉKQpG雲q'p0 HD&P"$Gfr'ʄo9J8zsP.~su!aS.<[{1GR.2ө-!GR+Ʉjm2p~ʅ(ӖZ3d ZME:%ɋTDS( IQ@8ΑṡR8 )UjLbQ!8byɭp\9CT(*ƇQz]z$~:S)$j:ϙS+5H/YRv--LVyJ|+^!pbj?,1l `>(^{(| m԰Kc2"Gp Bv?No94Ju`ۓjL)*NseTN]l= 5hhrKZ(r;OQ9h GXZ(z;x++3 T,6lS#\!0B8 +4R^\+/657\/ 's2ܴTcەDx(#ENA9g>\`٪q=M-.dvyz-F%6y1tBʲ5򦳭ĿANdɧL4"}Hk _.ZE`+?FUwj3H-I 6C!)J0ܺ#m5;E@ɡhX{a(Y {P +&;aXP-SX"je{C+: cP.ZO%8_0A:109ŀeQ <amYMui ] 9P[b"FrDZV2jLn87 ^6DU5" &3-9̽Sh D q]iۑLCM߼MLr*oBip-ob;9T߉7Wś/nNNomªTS)-puvY| .vMTAa0*?2 *Rl_~>?wM yfU!be(jMw$Ne`#;8Fh{RdSv\z(0єl*07JzblD35OPOQ] W7/c*g\MƊt,D~:HaNOi0K.zklC~} m2H.st!i5pD',3B:o(;T!C$Zx|>E L$TJ%5~YL}Z)ȱV(R.8[(spe$i'y!5tW,9A_]z2fe Xmo~q=R WVŹiJq̫6zc$[#X<[ON2:7ֽ~?!ʯ|Qvr>r+  I+n-?1KF3jxn5MJzDO 4WլV?ZIzG|a)Ny%;ߜ]}K l|Iɮ9托qlC]~Lg[fwX *ozD Kd)Dt~vq3$ 2ܳ0{6V]8t{ek[twETOdΈO #Or"*ZF)F;8:8޳oC^FϷR?Nb֘q' MʈԔ3PD'D.ŜRT&ã}eP zlМ],Lм!yS~qwaN|]GpM8mlP,LS 'mA9}!K'R~?&5a#ZYoX[8cvwMWDgpPb|UA6=#/Q}+kx@n]*>hJRxPE/=,E"IQ6" ( YNs&w̝j*.;Fd^XTLhl,&OB"7l'mq:B!Cld!>c )v NZѼ~Rm\/WR`KUg:Eq3q٩fad~[ ~w /oZۮkrv Ž[R[kw/rגg˙Ct^*jʶ095s۵x͊[Üg)[+\J4s7hFY@%w*Q/3O*<ԊBx:߽vH[77G>Kui/ȷ}˼H*zhsEE5_!~6Kt3yo1{֒MkˆOu-gJ )&(n| f^efg*!W.YGQQh{~<󐩿'իxWz,J!xO$ۄALpackage main import ( "database/sql" "encoding/json" "fmt" "net/http" "sync" "time" ) // StatsService serves the BlocksAPI surface //3, // backed directly by theA// // The Next.js explorer turns on config.features.stats when //P#(it points at this backend). Its /stats page // then requests /v1/counters and /v1/lines; without them it shows two error // banners ("Something went wrong" + "Some of the charts did not load because the // server didn't respond"). The indexer's own /v1/indexer/{slug}/stats endpoint // is a different shape and its chart endpoints are empty stubs, so we serve real // aggregates here, computed from evm_blocks / evm_transactions / evm_addresses. type StatsService struct { dbPath string mu sync.Mutex  db *sql.DB } // NewStatsService targets the default chain's indexer DB // ({dataDir}/{slug}/query/indexer.db). func NewStatsService(dbPath string) *StatsService { return &StatsService{dbPath: dbPath} } // conn lazily opens a read-only handle. The indexer writes in WAL mode, so a // read-only reader never blocks ingestion. The DB may not exist until the // indexer has created it, so open is retried per-request until it succeeds. func (s *StatsService) conn() (*sql.DB, error) { s.mu.Lock() defer s.mu.Unlock() if s.db != nil { return s.db, nil } db, err := sql.Open("sqlite3", "file:"+s.dbPath+"?mode=ro&_busy_timeout=3000") if err != nil { return nil, err } db.SetMaxOpenConns(2) if err := db.Ping(); err != nil { db.Close() return nil, err } s.db = db return db, nil } // Mount registers the stats-service routes on mux. func (s *StatsService) Mount(mux *http.ServeMux) {counters", s.handleCounterslines", s.handleLineslines/{id}", s.handleLinpages/main", s.handlePagesMain.pages/transactions", s.handlePagesTransactionspages/contracts", s.handlePagesContracts) } // ---- Wire shapes (match @luxfi/stats-types) ---- type statsCounter struct { ID string `json:"id"` Value string `json:"value"` Title string `json:"title"` Units string `json:"units,omitempty"` Description string `json:"description"` } type statsPoint struct { Date string `json:"date"` DateTo string `json:"date_to"` Value string `json:"value"` IsApproximate bool `json:"is_approximate"` } type statsLineInfo struct { ID string `json:"id"` Title string `json:"title"` Description string `json:"description"` Units string `json:"units,omitempty"` Resolutions []string `json:"resolutions"` } type statsLineChart struct { Chart []statsPoint `json:"chart"` Info statsLineInfo `json:"info"` } func writeJSON(w http.ResponseWriter, code int, v any) { 5w.WriteHeader(code) v) } // ---- Aggregate helpers ---- func (s *StatsService) count(db *sql.DB, table string) int64 { var n int64 // #nosec G201 — table is a fixed internal identifier, never user input. db.QueryRow("SELECT COUNT(*) FROM " + table).Scan(&n) return n } // avgBlockTimeSec returns the lifetime average block interval in seconds, // derived from the full timestamp span so it stays meaningful on a sparse, // demand-driven chain (per-window deltas collapse to zero when idle). func (s *StatsService) avgBlockTimeSec(db *sql.DB) float64 { var count, minTS, maxTS int64 db.QueryRow("SELECT COUNT(*), COALESCE(MIN(timestamp),0), COALESCE(MAX(timestamp),0) FROM evm_blocks"). Scan(&count, &minTS, &maxTS) if count < 2 || maxTS <= minTS { return 0 } return float64(maxTS-minTS) / float64(count-1) } // dailySeries buckets a COUNT by UTC day over the trailing `days` window. // timestamp is a unix-epoch integer, so strftime needs the 'unixepoch' modifier. func (s *StatsService) dailySeries(db *sql.DB, query string, days int) ([]statsPoint, error) { since := time.Now().AddDate(0, 0, -days).Unix() rows, err := db.Query(query, since) if err != nil { return nil, err } defer rows.Close() points := make([]statsPoint, 0, days) for rows.Next() { var day string var value int64 if err := rows.Scan(&day, &value); err != nil { return nil, err } points = append(points, statsPoint{Date: day, DateTo: day, Value: fmt.Sprintf("%d", value)}) } return points, rows.Err() } // ---- Handlers ---- func! (s *StatsService) handleCountersI,db, err := s.conn() if err != nil { writeJSON(w, http.StatusOK, map[string]any{"counters": []statsCounter{}}) return } blocks := s.count(db, "evm_blocks") txns := s.count(db, "evm_transactions") addrs := s.count(db, "evm_addresses") avgSec := s.avgBlockTimeSec(db) counters := []statsCounter{ {ID: "total_blocks", Value: fmt.Sprintf("%d", blocks), Title: "Total blocks", Description: "All blocks indexed on the chain"}, {ID: "total_txns", Value: fmt.Sprintf("%d", txns), Title: "Total transactions", Description: "All transactions indexed on the chain"}, {ID: "completed_txns", Value: fmt.Sprintf("%d", txns), Title: "Completed transactions", Description: "Transactions included in a block"}, {ID: "total_addresses", Value: fmt.Sprintf("%d", addrs), Title: "Total addresses", Description: "Distinct addresses seen on the chain"}, {ID: "average_block_time", Value: fmt.Sprintf("%.1f", avgSec), Title: "Average block time", Units: "s", Description: "Average interval between blocks"}, } writeJSON(w, http.StatusOK, map[string]any{"counters": counters}) } // lineInfos is the catalogue of charts this backend can serve, each backed by a // real SQLite aggregation. var lineInfos = map[string]statsLineInfo{ "newBlocksPerDay": { ID: "newBlocksPerDay", Title: "New blocks per day", Description: "Number of blocks produced each day", Resolutions: []string{"DAY"}, }, "newTxnsPerDay": { ID: "newTxnsPerDay", Title: "New transactions per day", Description: "Number of transactions each day", ResoClutions: []string{"DAY"}, }, } func (s *StatsService) handleLinesI,sections := []map[string]any{ { "id": "blocks", "title": "Blocks", "charts": []statsLineInfo{lineInfos["newBlocksPerDay"]}, }, { "id": "transactions", "title": "Transactions", "charts": []statsLineInfo{lineInfos["newTxnsPerDay"]}, },  } writeJSON(w, http.StatusOK, map[string]any{"sections": sections}) } func (s *StatsService) handleLine(w http.ResponseWrite^id := r.PathValue("id") info, ok := lineInfos[id] if !ok { writeJSON(w, http.StatusNotFound, map[string]any{"error": "unknown chart"}) return } db, err := s.conn() if err != nil { writeJSON(w, http.StatusOK, statsLineChart{Chart: []statsPoint{}, Info: info}) return } var query string switch id { case "newBlocksPerDay": query = `SELECT strftime('%Y-%m-%d', timestamp, 'unixepoch') d, COUNT(*) FROM evm_blocks WHERE timestamp > ? GROUP BY d ORDER BY d` case "newTxnsPerDay": query = `SELECT strftime('%Y-%m-%d', b.timestamp, 'unixepoch') d, COUNT(*) FROM evm_transactions t JOIN evm_blocks b ON t.block_number = b.number WHERE b.timestamp > ? GROUP BY d ORDER BY d` } points, err := s.dailySeries(db, query, 365) if err != nil { writeJSON(w, http.StatusOK, statsLineChart{Chart: []statsPoint{}, Info: info}) return } writeJSON(w, http.StatusOK, staQtsLineChart{Chart: points, Info: info}) } func (s *StatsService) handlePagesMainI,db, err := s.conn() if err != nil { writeJSON(w, http.StatusOK, map[string]any{}) return } blocks := s.count(db, "evm_blocks") txns := s.count(db, "evm_transactions") addrs := s.count(db, "evm_addresses") avgSec := s.avgBlockTimeSec(db) daily, _ := s.dailySeries(db, `SELECT strftime('%Y-%m-%d', b.timestamp, 'unixepoch') d, COUNT(*) FROM evm_transactions t JOIN evm_blocks b ON t.block_number = b.number WHERE b.timestamp > ? GROUP BY d ORDER BY d`, 30) writeJSON(w, http.StatusOK, map[string]any{ "total_blocks": statsCounter{ID: "total_blocks", Value: fmt.Sprintf("%d", blocks), Title: "Total blocks", Description: "All blocks"}, "total_transactions": statsCounter{ID: "total_txns", Value: fmt.Sprintf("%d", txns), Title: "Total transactions", Description: "All transactions"}, "total_addresses": statsCounter{ID: "total_addresses", Value: fmt.Sprintf("%d", addrs), Title: "Total addresses", Description: "Distinct addresses"}, "average_block_time": statsCounter{ID: "average_block_time", Value: fmt.Sprintf("%.1f", avgSec), Title: "Average block time", Units: "s", Description: "Average interval between blocks"}, "daily_new_transactions": statsLineChart{Chart: daily, Info: lineInfos["newTxnsPerDay"]}, }) } fun+c (s *StatsService) handlePagesTransactionsI,db, err := s.conn() if err != nil { writeJSON(w, http.StatusOK, map[string]any{}) return } var txns24h int64 db.QueryRow(`SELECT COUNT(*) FROM evm_transactions t JOIN evm_blocks b ON t.block_number = b.number WHERE b.timestamp > ?`, time.Now().AddDate(0, 0, -1).Unix()).Scan(&txns24h) writeJSON(w, http.StatusOK, map[string]any{ "transactions_24h": statsCounter{ID: "new_txns_24h", Value: fmt.Sprintf("%d", txns24h), Title: "Transactions (24h)", Description: "Transactions in the last 24 hours"}4, }) } func (s *StatsService) handlePagesContractsI,0writeJSON(w, http.StatusOK, map[string]any{}) } [N?`xPL Mnet/http/httptest" "path/filepath" "testing" "time" _ "github.com/mattn/go-sqlite3" ) // newTestStatsDB builds a minimal indexer DB mirroring the evm_* schema columns // the stats service reads: evm_blocks(number, timestamp[unix]), evm_transactions // (block_number), evm_addresses(hash). func newTestStatsDB(t *testing.T) string { t.Helper() dir := t.TempDir() path := filepath.Join(dir, "indexer.db")!patht.Fatal(err) } defer db.Close() _, err = db.Exec(` CREATE TABLE evm_blocks (number INTEGER PRIMARY KEY, timestamp INTEGER, gas_used INTEGER, gas_limit INTEGER, base_fee TEXT); CREATE TABLE evm_transactions (hash TEXT PRIMARY KEY, block_number INTENGER, gas_price TEXT); CREATE TABLE evm_addresses (hash TEXT PRIMARY KEY); `t.Fatal(err) } // 5 blocks over the last 3 days (30s apart within a day), 3 txns, 2 addrs. now := time.Now() for i := 0; i < 5; i++ { ts := now.AddDate(0, 0, -(i % 3)).Unix() + int64(i)*30 if _, err := db.Exec(`INSERT INTO evm_blocks(number,timestamp,gas_used,gas_limit,base_fee) VALUES(?,?,?,?,?)`, i+1, ts, 21000, 12000000, "0x5"); err != nil { t.Fatal(err) } }  for i := 0; i < 3; i++ { if _, err := db.Exec(`INSERT INTO evm_transactions(hash,block_number,gas_price) VALUES(?,?,?)`, fmt.Sprintf("0x%064d", i), i+1, "25000000000"); err != nil { t.Fatal(err) } } db.Exec(`INSERT INTO evm_addresses(hash) VALUES('0x01'),('0x02')`) return path } func TestStatsCounters(t *testing.T) { s := NewStatsService(newTestStatsDB(t)) rec := httptest.NewRecorder() s.handleCounters(rec, httptest.NewRequest(http.MethodGet, "/v1/counters", nil)) if rec.Code != 200 { t.Fatalf("status %d", rec.Code) } var out struct { Counters []statsCounter `json:"counters"` } if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil { t.Fatal(err) } got := map[string]string{} for _, c := range out.Counters { got[c.ID] = c.Value if c.Title == "" { t.Errorf("counter %s has empty title", c.ID) } } if got["total_blocks"] != "5" { t.Errorf("total_blocks = %q, want 5", got["total_blocks"]) } if got["total_txns"] != "3" { t.Errorf("total_txns = %q, want 3", got["total_txns"]) } if got["total_addresses"] != "2" { t.Errorf("total_addresses = %q, want 2", got["total_addresses"]) } } func TestStatsLines(t *testing.T) { s := NewStatsService(newTestStatsDB(t)) rec := httptest.NewRecorder() s.handleLines(rec, httptest.NewRequest(http.MethodGet, "/v1/lines", nil)) var out struct { Sections []struct { ID string  `json:"id"` Charts []statsLineInfo `json:"charts"` } `json:"sections"` } if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil { t.Fatal(err) } if len(out.Sections) == 0 { t.Fatal("no sections advertised") } found := false for _, sec := range out.Sections { for _, c := range sec.Charts { if c.ID == "newBlocksPerDay" || c.ID == "newTxnsPerDay" { found = true } } } if !found { t.Error("expected block/txn charts advertised") } } func TestStatsLineData(t *testing.T) { s := NewStatsService(newTestStatsDB(t)) for _, id := range []string{"newBlocksPerDay", "newTxnsPerDay"} { rec := httptest.NewRecorder() req := httptest.NewRequest(http.MethodGet, "/v1/lines/"+id, nil) req.SetPathValue("id", id) s.handleLine(rec, req) if rec.Code != 200 { t.Fatalf("%s status %d", id, rec.Code) } var out statsLineChart if err := json.Unmarshal(rec.Body.Bytes(), &out); err != nil { t.Fatal(err) } if len(out.Chart) == 0 { t.Errorf("%s returned no data points", id) } if out.Info.ID != id { t.Errorf("%s info.id = %q", id, out.Info.ID) } } } func TestStatsLineUnknown(t *testing.T) { s := NewStatsService(newTestStatsDB(t)) rec := httptest.NewRecorder() req := httptest.NewRequest(http.MethodGet, "/v1/lines/nope", nil) req.SetPathValue("id", "nope") s.handleLine(rec, req) if rec.Code != 404 { t.Errorf("unknown char)t status = %d, want 404", rec.Code) } } 螻x;package main import ( "database/sql" "encoding/json" "fmt" "net/http" "net/http/httptest" "path/filepath" "testing" ) // Full evm_blocks schema, matching what the indexer actually writes — the // shared stats harness only creates the columns /v1/counters needs. func newBlocksDB(t *testing.T, n int) string { t.Helper() path := filepath.Join(t.TempDir(), "indexer.db") db, err := sql.Open("sqlite3", path) if err != nil { t.Fatal(err) } defer db.Close() if _, err := db.Exec(` CREATE TABLE evm_blocks (number INTEGER PRIMARY KEY, hash TEXT, parent_hash TEXT, nonce TEXT, miner TEXT, difficulty TEXT, total_difficulty TEXT, size INTEGER, gas_limit INTEGER, gas_used INTEGER, base_fee TEXT, timestamp TIMESTAMP, tx_count INTEGER); CREATE TABLE evm_transactions (hash TEXT PRIMARY KEY, block_number INTEGER); CREATE TABLE evm_addresses (hash TEXT PRIMARY KEY); `); err != nil { t.Fatal(err) } for i := 1; i <= n; i++ { if _, err := db.Exec(`INSERT INTO evm_blocks (number,hash,parent_hash,miner,gas_limit,gas_used,base_fee,timestamp,tx_count) VALUES(?,?,?,?,?,?,?,?,?)`, i, fmt.Sprintf("0x%064d", i), fmt.Sprintf("0x%064d", i-1), "0x0000000000000000000000000000000000000001", 12000000, 21000, "0x5", 1700000000+i, 1); err != nil { t.Fatal(err) } } return path } func decode(t *testing.T, rec *httptest.ResponseRecorder) map[string]any { t.Helper() if rec.Code != http.StatusOK { t.Fatalf("status %d", rec.Code) } var body map[string]any if err := json.Unmarshal(rec.Body.Bytes(), &body); err != nil { t.Fatalf("bad json: %v -- %s", err, rec.Body.String()) } return body } // /v1/stats is the canonical flat summary. Values must be plain numbers so a // caller can compare total_blocks to eth_blockNumber without unwrapping an // envelope — that comparison is the only real check that the index is current. func TestV1Stats(t *testing.T) { s := NewStatsService(newBlocksDB(t, 7)) rec := httptest.NewRecorder() s.handleStats(rec, httptest.NewRequest(http.MethodGet, "/v1/stats", nil)) body := decode(t, rec) if got := body["total_blocks"].(float64); got != 7 { t.Errorf("total_blocks = %v, want 7", got) } if got := body["head_block"].(float64); got != 7 { t.Errorf("head_block = %v, want 7", got) } if body["indexed"] != true { t.Errorf("indexed = %v, want true", body["indexed"]) } } // A missing DB is a real state (fresh chain, indexer starting), not an error: // it must answer 200 with indexed=false so a health check can tell the two // apart, rather than 500ing. func TestV1StatsNoDB(t *testing.T) { s := NewStatsService(filepath.Join(t.TempDir(), "absent.db")) rec := httptest.NewRecorder() s.handleStats(rec, httptest.NewRequest(http.MethodGet, "/v1/stats", nil)) body := decode(t, rec) if body["indexed"] != false { t.Errorf("indexed = %v, want false", body["indexed"]) } } func TestV1Blocks(t *testing.T) { s := NewStatsService(newBlocksDB(t, 10)) t.Run("newest first, default page", func(t *testing.T) { rec := httptest.NewRecorder() s.handleBlocks(rec, httptest.NewRequest(http.MethodGet, "/v1/blocks", nil)) blocks := decode(t, rec)["blocks"].([]any) if len(blocks) != 10 { t.Fatalf("got %d blocks, want 10", len(blocks)) } if n := blocks[0].(map[string]any)["number"].(float64); n != 10 { t.Errorf("first block = %v, want 10 (newest first)", n) } if h := blocks[0].(map[string]any)["hash"].(string); h == "" { t.Error("hash must be populated") } }) t.Run("limit is honoured", func(t *testing.T) { rec := httptest.NewRecorder() s.handleBlocks(rec, httptest.NewRequest(http.MethodGet, "/v1/blocks?limit=3", nil)) if got := len(decode(t, rec)["blocks"].([]any)); got != 3 { t.Fatalf("got %d blocks, want 3", got) } }) t.Run("limit is bounded so a huge index cannot be dumped", func(t *testing.T) { rec := httptest.NewRecorder() s.handleBlocks(rec, httptest.NewRequest(http.MethodGet, "/v1/blocks?limit=99999", nil)) got := len(decode(t, rec)["blocks"].([]any)) // Assert the cap AND that rows actually came back — `got > 200` alone // passes trivially when the handler returns nothing, which is how the // scan-type bug slipped through the first run of this suite. if got != 10 { t.Fatalf("returned %d blocks, want all 10 (capped at 200)", got) } }) t.Run("before pages backwards", func(t *testing.T) { rec := httptest.NewRecorder() s.handleBlocks(rec, httptest.NewRequest(http.MethodGet, "/v1/blocks?before=5&limit=2", nil)) blocks := decode(t, rec)["blocks"].([]any) if len(blocks) != 2 { t.Fatalf("got %d blocks, want 2", len(blocks)) } if n := blocks[0].(map[string]any)["number"].(float64); n != 4 { t.Errorf("first block = %v, want 4 (strictly before 5)", n) } }) } // Every route this service mounts lives under /v1 and none under /api. func TestStatsRoutesAreV1Only(t *testing.T) { mux := http.NewServeMux() NewStatsService("/nonexistent.db").Mount(mux) for _, p := range []string{"/v1/stats", "/v1/blocks", "/v1/counters", "/v1/pages/main"} { if _, pattern := mux.Handler(httptest.NewRequest(http.MethodGet, p, nil)); pattern == "" { t.Errorf("%s is not mounted", p) } } // /api/v2 is Blockscout's shape and must not exist here. if _, pattern := mux.Handler(httptest.NewRequest(http.MethodGet, "/api/v2/stats", nil)); pattern != "" { t.Errorf("/api/v2/stats must NOT be mounted, got pattern %q", pattern) } } %x\koǒL;C[ Uؒ^KVD%$犜gz!`?-_9U )Y`\qէNUd.5(I"Klu,-uşqTFèӌm:$Zd)nM+eZ "*q22GyWܤ#>*nmu>$)a8yTi`ꤴ߲Ely=No$UxǷxW(pSXD"bBEQ׆rH iʅ~ULZ;j6Ip+ U`QtQ5tVVin%~j1%d޳/> Wp0XG;]# |?v^ Z^՗Aۙ--lCg,J^_mP y:Z18"lQlxwT{Ӄ_f" $7^aX =aS4bP+N 3(Hv|S8V;-[,G,R WQ.:q:ȱcihAd;62 8g_|Y;x+G2O(mllBE|s됤@ALQϨ504hS0G]M CD 5/1@~(SV%4pP-8FL:o0y}uNxYiI IX)៳wL^:Vpl."A7s1 kWX$Աi!60s%;pS* 60?h*^fhW@"./Ҝ˯EagE dG KxIe%-|-ү@ d2-hm"^H8qsa3`1tXg}&!Dc:TNik<>_c!ĚXmwɹa۫As>gw߻|m#Qx1YP&IaCM[f~y:C05jgȘG9mdĉ8azSì pĦ6OFDbXdD9@>J#c# {iSM)c37 Pm>DG ̙~/UCBO #b5zϝX׍w}ΠbMX2+KIHL$; '] gE=Z04gdtWRn~0-)D.R1=+f1$Leʹ;w^w l=5z E/uyҸۭ<)2;Q6RZZh& Y V7 ox)٣Ĉ#3Ћ9OӰ7P v J8FPRNs2 i{ _d\\SXf47d¹G+'P xVniG54 мq%a%\ d!-=dxN@2 @55AXA8+W,Aob&PBɤFB= #=_3U.ı#iG5_F3&e}9Xf<طՋGJR@97*O7eyQs?iR ݊'e_K~봰U/M2HxrC(ٙ3u8eҲqdo;:]pP%.L*jQ]G#;A!ʘ+/Q'#vQ@MLn|WGo|8Ó^Ft!!tԫ$d,FEVP_kc]KNmg’r%>T+kVNUd jLUdļY+DG2,&PN^)$p֍Nj``d3Y@^\&3#RD;= {v/;Gh{8pr)%uŸL>w26WZ^ Yl1p])~72rY ǡ]7/oe!^E<7fOn4Z8@-Az;whUb?ޞto~t5,Q*(A7<#4 /4"]!S+Geˠ+Mri&. fHrQM_!?z(E DӊX UWg[vW2G+Fo1H!ѵ%R=};87ݧz P+(_!D^ы'Y5o6^'4Պ3|GnY@."&P>Lo,ddN۟f*-34Kfip"EZZRVNU+Z$&הZ1S]SHQITqo 7JVR!P&sW"#ݺg ;OH؂C 1"=f">"cH #?Y6E?6[k#L_-,?xlu#%xeCb,uZ8:9:y$o&mEjI_R,#!.pw&|q(/-dzvdJm5^8IF( $uxvkjEy\68}`aclg+juK3|qAw ꀊe[l0al[ U>GD?H¨fŸmS"?B&].=h9{r 8ԩ~١_ul}|aKPIbhJSHba#TdF~^tC%݇rӌ[&(dufbƯJ7飐V*N\8(d9,lx#INp$优 vY:ԾN־uq@yp|ք IAa-Z۳ՉpצL4dS{|jQ`j 攅$߀3D{.xvy|[?P(Gv5.< _xdT* // Native-coin balances come from the chain, not from the // index — the same RPC this chain is indexed from. RPCEndpo int: cfg.RPCP*C3 xñcBտdS-nZRጡK~rvjQZfN*Ԏy=OTb\Vic?~igՒ_vl^ɘ=讍Q+~u_MjpQjzfqIQe|Ijq^z>/M;o 3p|}H2x~{3Mu):)8P\I砓nv*- `Fϔn@4& ha|y:އI}100644 registry_test.go#1y͵;v戻hu̓WJ7{x$40000 workflowsכv}IG\8Lx'100644 release.yml Pab-Q@½ Q "xVn6H"IM)G00'V#mN֢+RZe62钔/ͰIv(Ib!Q8{Nw\a(厳/(<10X֩iIZ#7ti$7 6*_Eґf.,EzER(ɍMtX35&n6bkUJ3aD[G#_W'Q<!0^y·VLOFcTtSKT(G$1}i=D#2w46zJyq7-4ZXEXi npfu" fNWqvpm ?8_1- Q(9#Ԕ>JDAV0#AA0%+S1i f,IhZ؜aٯt|̤50zD:3rA8O)_ uDVsә. ]ɕwIG{#gt!b%F[˪;8PVV:4S-lHC@1/@Гz=;?8iPz!$U}<ӳR $G7iyaw@^} 5)F!ΖE[?@6%~\^ Wk.Nwpyqtpiytw7OnSdMu{Vʄ@ #H ؖ -inzGnUyA+, Nc pce ) |$ /kL4dɴQҥfZOc[AGbPQuF~γ[-7>;t. f kf O4z uj#/8JeiwL`, @4!U0 ŝyjɿUu]cst}ݻt/GړѪ3gP?*XsbޣHb ZU=ጦo5c C NNEZuҪi;k g0bj,;d.Gn3*0Qf}(QaM+iZ*AE;xՍ%ELǔl5kQ.pػnZO?o^wS|7χe@R9^x̃:nýAb*WU&Kk' Wf/.冾}CĠn!zvgHV9} '+EVx..e~άgeOxX}۶ fYS].-NGKņC3, 3D>o=T|#Xe9ʢƱp0Zn FW6,{^dd4 9;Zn9]͔ 6I]2y&26`i6n_FuN<\p/aeYnX(2ft7͋,3_Ν$Dp)O[O3VoQ|ϰڰ͋(*g\K^^fbka=+Z\f z-N]2R/|_#: RXƙű`-״N7ﻄY8@lH*5WV Dy%ck)TfJ5@Xz3 1om9EĸLW+FR{E#-%!H*ZhªsCl!G~۱3jCG4W>_k|uuwd~.Fv i}t>CUl)f͔Yxɧl%]e9Pv85oRCXx`7o~:\,pm®Yqp˹#R+x{AVLŬ6gtz6Vl )M6HN6MD锫gO nW{#zgkd&a'i"fK7Iq1'P8vr3I~l.Ǭ)qui$ݞkjNe.tM9j( jm›l?ڑ8#^d>,c|\?nF{"M5n=~w)m5~c1T!$;2#4Iz-QaiQdž"֞Z5PV6Nc4r:I C\ĥvΡP6+=*w׸>igh 'Eq$bОӬtEYl4Q2*WfƶH- !k+V;i4tg~j|Niڤ:(7ܡikt8SSG&wЀ;@L]б|_CQV[;671u8%4)_#YX+\`<{>m|n??>}r]E])~0iߪ[(?/~̥,* 12d!23af5F >jwvivQ%@WY)1 @{%$p=ȞGCp@MdmeC0,9W`ԟ@KC}i}c#Ȕ$~"6˝{``wJ?\ܸ}|w R#Gg=V?p1Qv{1=T䔝 ($S)To,])X) ?P{()Mիq~Tv1?b6:6](ϧBFL@>+= VW AD->_0R>>7:թDa,ĽD:8o<  0mH^},2R4AZǭ)'?/6upDPL9Ue4Λ퉒d JH/~ͣsE)xd GQƄ.REm`\ 9 yeTr*;A~(ISeEa>X% QgK>c(Ѹq)x9)[*{@mKl-"ZTlǗv=-}q=܏[9AKxKc;݊OkʕCX4/Zg!cGHKO7χ<콮3Y-i LDE+#PgK6ZCyYK]{Ntn9Ð-z(IMr9-Eoh~&֞][i&=nЎbߎچW')ecٶqzj`cM˚Hm+|W.kU ;S Q(pIIeRh;Fl?:\G=]EI m-yeU\3M8!+!ݹh)R%UUHB|J {im,ϸ4n5ǻ<  ylU0+Tktj2drd}%&3J ?lu6e,m3aTd;q{aB/AK,Hw7&m=&9&\ _F.G^kK2# :RЗ5ߦC0dIbS[}5.Wst(Z9onNnB 2rѡ|XKֵI=?utĝ1XߛAY焟"$m!t2AC ̇^8W4d@=2|+<-CLVCh?\ j,=hnGW*)]jJ4xU::JT1; legacy `chains: [...]` YAML shape used by tests and the // minimal config. The full Config struct in config.go is the canonical schemapE< sup *ChainSupervisor // nil = registry-only mode (tests)ZttachSupervisor wires a ChainSupervisor so admin/config/mdns adds also // spawn per-chain indexer + graph goroutines, and removes cancel them AttachSupervisor(s *ChainSupervisor) { r.sup = s } // Add registers a chain. mDNS-sourced chains never override higher-prioritLy // (config/env/admin) entries; admin/config/env duplicates return an error .B .mu.Unlock()Kd .mu.Unlock()K(0{!.mu.Unlock() return nil }1 r.mu.Unlock()?) if r.sup != nil { r.sup.start(cfg) }/ t % .mu.Unlock() , r.mu.Unlock() ) if r.sup != nil { r.sup.stop(slug) }5 " ) .mu.Unlock() " 8 $( updated := entry.Config r.mu.Unlock() u @ if r.sup != nil { r.sup.stop(slug) r.sup.start(updated) } ! ճ >d using the legacy `chains: [...]` // shape. Full Config (with brand, networks, etc.) loads via LoadCn OvK\c.WS = os.Expand(c.WSi/aI2&N[5B“س`pZ-kxC 6P Ղ100644 go.sumGwq#<$W cn䍳@sx{^gvf=y7]$ M0n xO 6w?ݥ&x31̒$c5c={.[9a%굡 XIfz^~Q*ķQa͌2?ȼQѮPU.٩Ei9 ?~|^8y\]|]rSl/hiSu_(PEyz9z9 mn[鯝j|Ynˌ[as [8tygY_YU laKGҦv:ăPQ\trf>9wv6Oӈ;U t^z>;wUrIrܫaJRN*ad2TⴔcMJMM K3tSsRS3ήֈlg//kaE9% .Cnif/)/I-.xШy՗>8q{Z 6=,+jZxeUd `4ep#8ڨ,=%KfꛀPqrQfAI1='%_-Wmv,x+"40000 .githubje}ZLuֱ"Cda:x+"40000 .github#+{"Ȼ9<;'""CJS`9x+"40000 .github^$':ry.bI"CM9x __ֈm2mWw1<&vܢXNsH I.x+"40000 .github*ߎ% w@KA뉭<%f"C99x+"40000 .githubmPϝ"CnF9x4 (E2գ_u)H #-x<40000 .githubsΣjQJh100644 .gitignoreEyTH))S7>rš 100644 config.goؽ#N!,y^R100644 frontend.go3d=<@>5c&100644 go.modm(śS^n b100644 go.sum7uJ !*gr100644 main.goBo X 8V0_9BLP&c@o:źZj+F)pL100644 registry_test.goYs5ZCC"J40000 static01~tHT4100644 supervisor.gob|3yaG-,J9'P5ܣJx+"40000 .githubMxC{V䯱Qckh"K`:x!eӃݚwdZ+q9>yX E/xE"40000 .github&қ_#{(a*к"C7uJ !*gryX!7Sx[$rQjٓU! [-xeD40000 .claude,9;- u40000 .github.B41d*"8_Efse`Rnc+sx "4' À !6œ㝶>jZG.xC"40000 .github~?צ~S<Q"8lpS @jwnc>Qx+"40000 .github ,d/`j*^Nm"K9xZL`>$T,]$.YIuqnc b-x+"40000 .github!rF40000 workflows4:9?H,Qsx\y\xOO;M9g|R% 'xOO;uz] 84m0Wʭ 'xOO;'Ma:Cu:jh| N'xOO;Hz Y̥?{Umo F'xOO;Y\`0 ͆ 'xOO;bU_`,vܿF 'xOO;Ԥv߫4ko* 'xOO;K"0pj;(d 8 8x&100644 docker.ymlCbj{!_Gj`Gq~`x name: Docker on: workflow_dispatch: push: tags: ['v*'] permissions: contents: read packages: write id-token: write # amd64-only on luxfi's native ARC pool — the SPA build (Next.js + 8GB # heap) + Go cgo-sqlite Docker build under QEMU arm64 emulation pushes # build time from ~5 min to ~2 hours. Cluster runners are amd64; Mac # devs use OrbStack which has its own arm64 base image story. arm64 # rebuilds can come back via a separate matrix entry on a native # arm64 runner — not via QEMU. jobs: docker: runs-on: lux-build steps: - uses: actions/checkout@v4 - uses: docker/setup-buildx-action@v3 with: driver: docker-container driver-opts: network=host - uses: docker/login-action@v3 with: registry: ghcr.io username: ${{ github.repository_owner }} password: ${{ secrets.GITHUB_TOKEN }} - id: meta uses: docker/metadata-action@v5 with: images: ghcr.io/luxfi/explorer flavor: latest=auto tags: | type=semver,pattern={{version}} type=semver,pattern={{major}}.{{minor}} type=sha,prefix=sha- - uses: docker/build-push-action@v6 with: context: . platforms: linux/amd64 labels: ${{ steps.meta.outputs.labels }} tags: ${{ steps.meta.outputs.tags }} cache-from: type=gha,scope=explorer cache-to: type=gha,scope=explorer,mode=max provenance: false push: true Mx* Multi-arch on luxfi org's native amd64 ARC runner pool; arm64 via QEMU # (matches lux/graph + lux/indexer docker.yml). Mac devsP run native arm64 # under OrbStack — zero Rosetta is allowed. Semver tags onlyhanzo-build-linux-amd64$Iqemu#platforms: linux/arm6P ,linux/armi9x s lux-buildKbsx8# Binaries bin/ explorer explorer-unified *.exe *.test # Coverage coverage.out coverage.html # Go workspace go.work go.work.sum # Editor .idea/ .vscode/ *.swp *.swo # OS .DS_Store # Local .env .env.local *.local # AI assistant context (not committed) AGENTS.md CLAUDE.md GEMINI.md QWEN.md # Runtime logs/ 8TcEx,# Binaries bin/ /explorer) .claude/ = ۶xXn8笠pI18f[gc1mN'Eph9DHqgC%aٙLEC{7pg>'`Oq Y02`p-`#l9}<>#=ko`xTB M8t†+oEy$- 8 h k1K$ ->U >| E)thΏFɔl@$<cUp=}rǓp4 l0ӳ3̽cw6vGCgT,[Dӹҧ Yqp[aouwL+MnUL]ۣ2/7r#O?0QXQh KZ1]BW{.^_$<0]x<j'T1 J$4Y4 rEcfXqѠM^Y c" J_@0JeBN,3C DI7^gHrgUX l+Ȫ}oqgU D{) f9$O^pq~a}:u6"ymwcw<|}m|7| 0VN765eRX`[Elu V]t+ݯڠ!XP C.^j@x 3GYpCј@K;Xh' $HRf$v!z-S !>ioy[%P]`c)ab麟UיGU{Fc]&/V* )ϯ4U5?u` cvzi>!c1oypfʄpQ_.w0BHh߰ŲE;—"Kx=_\9/e0|r†7D.3L=/IÿX 6>K@5@IA q!qVE)s(< |"2EI<iU͓BSʥ/̪z>[ʎa*$5_U6e8s2e+CyƳ6Yђ!UT%i8o fWTP  ?k4t[N( V47SU*T bՊLk`J'!CjɪhOiWo rG2#7i-m:)kH&s S.Y KxpTPWo( T=x?IRAO0o%_}"[J2ǭ}wwWY ٟtՅ߀G\Յ\i@m ʊ ~ h)+v* X`G捾+8 @RxenwOݭÈn{ڞ!/;LY;Nk<7n?ܸvI4pO1D'vBHUipk됀[A"Z R V{BnѰ7—zEk FKx\h+dcVk'a|q4`ɋ8 rJ3sRjjJJSBrS2t  KKjty)z%9 1\ @n\RY),Is(/J-чulR22SlKl|;u;llǨVk $JRRn/.I,L|ϟS*UAxe# Explorer Single-binary Lux explorer: chain indexer, GraphQL engine, and SPA frontend in one Go process. Imports [`luxfi/indexer`](https://github.com/luxfi/indexer) and [`luxfi/graph`](https://github.com/luxfi/graph) as libraries; embeds the [`luxfi/explore`](https://github.com/luxfi/explore) Next.js build via `go:embed`. ``` ghcr.io/luxfi/explorer -> indexes one or more EVM chains (luxfi/indexer) -> exposes per-chain GraphQL (luxfi/graph) -> serves embedded SPA + REST API (luxfi/explore) ``` ## Routes | Path | Purpose | |---------------------------------------------------|----------------------------------| | `/` | SPA (embedded; SPA-routing fallback) | | `/envs.js` | Runtime config `window.ENV = {...}` | | `/icon.svg`, `/logo.svg` | Per-host brand assets (disk override) | | `/health` | Service health | | `/v1/indexer/*` | Default chain explorer API | | `/v1/indexer/{slug}/*` | Per-chain explorer API | | `/v1/explorer/{slug}/*` | Legacy alias for `/v1/indexer/{slug}` | | `/v1/graph/{slug}/{subgraph}/graphql` | Per-chain, per-subgraph GraphQL | | `/v1/explorer/admin/chains[/{slug}]` | Runtime registry CRUD | | `/v1/explorer/realtime` | WebSocket realtime hub | | `/v1/explorer/realtime/stats` | Realtime stats | ## Quick Start ```bash docker run -p 8090:8090 \ -v $(pwd)/chains.example.yaml:/etc/explorer/chains.yaml:ro \ -v explorer-data:/data \ ghcr.io/luxfi/explorer:latest \ --config /etc/explorer/chains.yaml ``` Or with compose: ```bash docker compose up ``` ## Configuration `chains.yaml` is the single source of truth. Every aspect of the deploy -- chains, branding, GraphQL subgraphs, network switcher links -- is per-chain customizable. See [`chains.example.yaml`](chains.example.yaml) for the full schema. ```yaml data_dir: /data http_addr: :8090 brand_default: name: Lux Explorer coin: LUX accent_color: "#5cf" networks: - { label: Mainnet, domain: explorer.lux.network, chain_id: 96369 } chains: - slug: cchain name: Lux C-Chain chain_id: 96369 type: evm rpc: https://api.lux.network/mainnet/ext/bc/C/rpc coin: LUX enabled: true default: true indexer: poll_interval: 30s graph: enabled: true subgraphs: - { name: amm, schema: amm, enabled: true } brand: name: Lux C-Chain accent_color: "#5cf" ``` `$ENV_VAR` substitution in `rpc:` / `ws:` lets one file template every network -- mount it read-only and inject secrets via env vars. ## Per-Network Customization The same image powers every deploy. To rebrand for a different network: 1. Mount a different `chains.yaml`. 2. Optionally mount `icon.svg` / `logo.svg` at the path referenced by `chains.yaml` -- they are read from disk per-request, not embedded. 3. Set environment variables to fill the `${VAR}` placeholders. No image rebuild needed. The SPA reads chain list and brand at runtime from `/envs.js`. ## Runtime Registry Chains can be added, updated, and removed at runtime without restart: ```bash # Add curl -X POST http://localhost:8090/v1/explorer/admin/chains \ -H 'Content-Type: application/json' \ -d '{"slug":"new","name":"New","chain_id":123,"rpc":"http://node:8545","type":"evm"}' # List curl http://localhost:8090/v1/explorer/admin/chains # Remove curl -X DELETE http://localhost:8090/v1/explorer/admin/chains/new ``` Adding a chain spawns its indexer + (optional) graph workers; removing cancels them and frees the routes. ## mDNS Discovery Set `EXPLORER_MDNS=true` to auto-register chains advertised by local Lux nodes (`_luxd._tcp`, `_zood._tcp`, `_hanzod._tcp`, `_parsd._tcp`). The explorer queries `info.getChains` on the discovered node and registers each tracked chain. mDNS-sourced chains never override config-sourced entries. ## Storage Layout ``` /data/ cchain/ query/indexer.db (SQLite WAL, indexer) {zapdb}/ (KV store) graph/ amm/graph.db (SQLite WAL, per-subgraph) zoo/ ... ``` Each chain (and each subgraph) owns an isolated SQLite + KV store. WAL is optionally streamed to S3 with PQ encryption when `REPLICATE_S3_ENDPOINT` is set -- see `luxfi/indexer/daemon`. ## Local Build ```bash # Sibling layout: ~/work/lux/{indexer,graph,explorer} cd ~/work/lux/explorer go build -o explorer . ``` `go.mod` uses local `replace` directives pointing at `../indexer` and `../graph`. Production CI clones all three repos into the same layout inside the Docker build. ## Endpoints (curl examples) ```bash curl http://localhost:8090/health curl http://localhost:8090/v1/indexer/cchain/blocks/latest curl -X POST http://localhost:8090/v1/graph/cchain/amm/graphql \ -H 'Content-Type: application/json' \ -d '{"query":"{ swaps(first:5) { id amount0 amount1 } }"}' ``` ## Related - [`luxfi/indexer`](https://github.com/luxfi/indexer) -- chain indexer library - [`luxfi/graph`](https://github.com/luxfi/graph) -- per-chain GraphQL library - [`luxfi/explore`](https://github.com/luxfi/explore) -- Next.js SPA xD# chains.example.yaml — full per-network customization for the unified Lux # explorer. Mount as /etc/explorer/chains.yaml or pass --config=chains.yaml. # # Every chain gets its own SQLite file under {data_dir}/{slug}/ and its own # /v1/indexer/{slug}/* + /v1/graph/{slug}/{subgraph}/* routes. Branding is # per-chain; the SPA reads it at runtime via /envs.js so a deploy can # rebrand by remounting this file + assets — no image rebuild. data_dir: /data http_addr: :8090 # Default branding the SPA uses when the request hostname does not match a # chain-specific brand below. Per-chain `brand:` overrides win. brand_default: name: Lux Explorer coin: LUX accent_color: "#5cf" icon_url: /icon.svg logo_url: /logo.svg # Cross-explorer link list rendered in the SPA's network switcher. networks: - label: Mainnet domain: explorer.lux.network chain_id: 96369 - label: Testnet domain: testnet.explorer.lux.network chain_id: 96368 - label: Devnet domain: devnet.explorer.lux.network chain_id: 96370 chains: # ── Lux native chains ───────────────────────────────────────── - slug: cchain name: Lux C-Chain chain_id: 96369 type: evm rpc: ${LUX_CCHAIN_RPC:-https://api.lux.network/ext/bc/C/rpc} coin: LUX enabled: true default: true indexer: { poll_interval: 30s } graph: enabled: true subgraphs: - { name: amm, schema: amm, enabled: true } - { name: securities, schema: securities, enabled: false } brand: name: Lux C-Chain coin: LUX accent_color: "#5cf" - slug: pchain name: P-Chain type: linear rpc: ${LUX_RPC:-https://api.lux.network}/ext/bc/P coin: LUX enabled: true - slug: xchain name: X-Chain type: dag rpc: ${LUX_RPC:-https://api.lux.network}/ext/bc/X coin: LUX enabled: true - slug: achain name: A-Chain type: dag rpc: ${LUX_RPC:-https://api.lux.network}/ext/bc/A coin: LUX enabled: true - slug: bchain name: B-Chain type: dag rpc: ${LUX_RPC:-https://api.lux.network}/ext/bc/B coin: LUX enabled: true - slug: qchain name: Q-Chain type: dag rpc: ${LUX_RPC:-https://api.lux.network}/ext/bc/Q coin: LUX enabled: true - slug: tchain name: T-Chain type: dag rpc: ${LUX_RPC:-https://api.lux.network}/ext/bc/T coin: LUX enabled: true - slug: zchain name: Z-Chain type: dag rpc: ${LUX_RPC:-https://api.lux.network}/ext/bc/Z coin: LUX enabled: true - slug: kchain name: K-Chain type: dag rpc: ${LUX_RPC:-https://api.lux.network}/ext/bc/K coin: LUX enabled: true # ── Lux subnet chains (EVM) ─────────────────────────────────── - slug: zoo name: Zoo chain_id: 200200 type: evm rpc: ${ZOO_RPC:-https://api.lux.network/ext/bc/Zoo/rpc} coin: ZOO enabled: true indexer: { poll_interval: 30s } graph: enabled: true subgraphs: - { name: amm, schema: amm, enabled: true } brand: name: Zoo coin: ZOO accent_color: "#7c3aed" - slug: hanzo name: Hanzo chain_id: 36963 type: evm rpc: ${HANZO_RPC:-https://api.lux.network/ext/bc/Hanzo/rpc} coin: HANZO enabled: true indexer: { poll_interval: 30s } graph: enabled: true subgraphs: - { name: amm, schema: amm, enabled: true } brand: name: Hanzo coin: HANZO accent_color: "#0b1220" - slug: spc name: SPC chain_id: 36911 type: evm rpc: ${SPC_RPC:-https://api.lux.network/ext/bc/SPC/rpc} coin: SPC enabled: true indexer: { poll_interval: 30s } - slug: pars name: Pars chain_id: 494949 type: evm rpc: ${PARS_RPC:-https://api.lux.network/ext/bc/Pars/rpc} coin: PARS enabled: true indexer: { poll_interval: 30s } - slug: dex name: Lux DEX type: evm rpc: ${LUX_RPC:-https://api.lux.network}/ext/bc/D/rpc coin: LUX enabled: true indexer: { poll_interval: 15s } graph: enabled: true subgraphs: - { name: amm, schema: amm, enabled: true } - { name: clob, schema: all, enabled: true } # ── External chains (bridge / MPC counterparties) ───────────── - slug: ethereum name: Ethereum chain_id: 1 type: evm rpc: ${ETH_RPC:-https://eth.llamarpc.com} coin: ETH enabled: false graph: enabled: false subgraphs: - { name: uniswap-v3, schema: uniswap-v3, enabled: true } - slug: arbitrum name: Arbitrum One chain_id: 42161 type: evm rpc: ${ARB_RPC:-https://arb1.arbitrum.io/rpc} coin: ETH enabled: false - slug: optimism name: Optimism chain_id: 10 type: evm rpc: ${OP_RPC:-https://mainnet.optimism.io} coin: ETH enabled: false - slug: base name: Base chain_id: 8453 type: evm rpc: ${BASE_RPC:-https://mainnet.base.org} coin: ETH enabled: false - slug: polygon name: Polygon chain_id: 137 type: evm rpc: ${POLYGON_RPC:-https://polygon-rpc.com} coin: MATIC enabled: false - slug: bsc name: BNB Chain chain_id: 56 type: evm rpc: ${BSC_RPC:-https://bsc-dataseed.binance.org} coin: BNB enabled: false - slug: avalanche name: Avalanche C-Chain chain_id: 43114 type: evm rpc: ${AVAX_RPC:-https://api.avax.network/ext/bc/C/rpc} coin: AVAX enabled: false - slug: solana name: Solana type: solana rpc: ${SOL_RPC:-https://api.mainnet-beta.solana.com} coin: SOL enabled: false - slug: bitcoin name: Bitcoin type: bitcoin rpc: ${BTC_RPC:-} coin: BTC enabled: false - slug: cosmos name: Cosmos Hub type: cosmos rpc: ${ATOM_RPC:-https://cosmos-rpc.publicnode.com} coin: ATOM enabled: false _Ηlx2package main import ( "fmt" "os" "regexp" "gopkg.in/yaml.v3" ) // Config is the top-level explorer configuration loaded from chains.yaml. type Config struct { DataDir string `yaml:"data_dir"` HTTPAddr string `yaml:"http_addr"` StaticDir string `yaml:"static_dir"` // overlay dir for SPA; empty = embedded only BrandDefault Brand `yaml:"brand_default"` Networks []Network `yaml:"networks"` Chains []ChainConfig `yaml:"chains"` } // ChainConfig defines a single chain plus per-chain customization. The // admin/registry/mdns layer also uses this shape; fields beyond Slug/Name/ // ChainID/RPC/Type/Default are optional and apply when the chain is loaded // from a config file. type ChainConfig struct { Slug string `json:"slug" yaml:"slug"` Name string `json:"name" yaml:"name"` ChainID int64 `json:"chain_id" yaml:"chain_id"` Type string `json:"type" yaml:"type"` // evm, dag, linear, solana, bitcoin, cosmos RPC string `json:"rpc" yaml:"rpc"` WS string `json:"ws" yaml:"ws"` CoinSymbol string `json:"coin" yaml:"coin"` Enabled bool `json:"enabled" yaml:"enabled"` Default bool `json:"default" yaml:"default"` Source string `json:"source" yaml:"-"` // config, env, mdns, admin Indexer IndexerSettings `json:"indexer,omitempty" yaml:"indexer,omitempty"` Graph GraphSettings `json:"graph,omitempty" yaml:"graph,omitempty"` Brand *Brand `json:"brand,omitempty" yaml:"brand,omitempty"` Tokens TokensFeatures `json:"tokens,omitempty" yaml:"tokens,omitempty"` } // IndexerSettings overrides indexer behaviour for a single chain. type IndexerSettings struct { PollInterval string `yaml:"poll_interval" json:"poll_interval,omitempty"` // e.g. "30s" StartBlock uint64 `yaml:"start_block" json:"start_block,omitempty"` } // GraphSettings configures per-chain GraphQL subgraphs. type GraphSettings struct { Enabled bool `yaml:"enabled" json:"enabled"` Subgraphs []Subgraph `yaml:"subgraphs" json:"subgraphs,omitempty"` } // Subgraph mounts a single named GraphQL schema under // /v1/graph/{chain-slug}/{subgraph-name}/. Schema is either a built-in name // understood by github.com/luxfi/graph/engine.LoadBuiltin (amm, uniswap-v2, // uniswap-v3, uniswap-v4, securities, fhe, etc.) or a path to a .graphql file. type Subgraph struct { Name string `yaml:"name" json:"name"` Schema string `yaml:"schema" json:"schema"` Enabled bool `yaml:"enabled" json:"enabled"` } // Brand is the per-chain (or default) UI branding shown by the SPA. Icon/Logo // files are read from disk on every request so a deploy can swap them without // rebuilding the binary. type Brand struct { Name string `yaml:"name" json:"name,omitempty"` Coin string `yaml:"coin" json:"coin,omitempty"` AccentColor string `yaml:"accent_color" json:"accentColor,omitempty"` IconFile string `yaml:"icon_file" json:"-"` LogoFile string `yaml:"logo_file" json:"-"` IconURL string `yaml:"icon_url" json:"iconUrl,omitempty"` LogoURL string `yaml:"logo_url" json:"logoUrl,omitempty"` } // TokensFeatures controls which tokens the SPA highlights or hides. type TokensFeatures struct { Featured []string `yaml:"featured" json:"featured,omitempty"` AllowList []string `yaml:"allow_list" json:"allowList,omitempty"` BlockList []string `yaml:"block_list" json:"blockList,omitempty"` } // Network is a peer explorer the SPA can link to in its network switcher. type Network struct { Label string `yaml:"label" json:"label"` Domain string `yaml:"domain" json:"domain"` ChainID int64 `yaml:"chain_id" json:"chainId"` } // slugPattern restricts chain slugs to lowercase alphanumeric + hyphen so they // remain safe in URL routes (/v1/indexer/{slug}/) and filesystem paths. var slugPattern = regexp.MustCompile(`^[a-z0-9][a-z0-9-]{0,63}$`) // LoadConfig reads chains.yaml, expands $ENV_VAR in RPC/WS, and validates slugs. func LoadConfig(path string) (Config, error) { data, err := os.ReadFile(path) if err != nil { return Config{}, fmt.Errorf("read %s: %w", path, err) } var cfg Config if err := yaml.Unmarshal(data, &cfg); err != nil { return Config{}, fmt.Errorf("parse %s: %w", path, err) } for i := range cfg.Chains { cfg.Chains[i].RPC = os.Expand(cfg.Chains[i].RPC, os.Getenv) cfg.Chains[i].WS = os.Expand(cfg.Chains[i].WS, os.Getenv) if !slugPattern.MatchString(cfg.Chains[i].Slug) { return Config{}, fmt.Errorf("chain[%d]: invalid slug %q", i, cfg.Chains[i].Slug) } } return cfg, nil } = l@x $#byx'package main import ( "bytes" "embed" "encoding/json" "fmt" "io/fs" "net/http" "os" "path/filepath" "strings" "sync" ) // staticFS is the embedded SPA. The Dockerfile populates static/ from a // luxfi/explore build before the Go build runs; for local dev a placeholder // index.html is committed so go:embed always succeeds. // //go:embed all:static var staticFS embed.FS // Frontend serves the embedded SPA, runtime config (/envs.js), and per-host // brand assets (/icon.svg, /logo.svg). Brand assets read from disk on every // request so a deploy can swap them without rebuilding the binary. // // SPA override: if cfg.StaticDir (or $EXPLORER_STATIC_DIR) points at an // existing directory, file lookups prefer the on-disk copy over the // embedded FS. This lets a ConfigMap-mounted SPA replace the embedded // 60-byte placeholder without a binary rebuild — useful when the // upstream `explore` Next.js app hasn't shipped a static export yet but // we want a richer in-cluster default than `
`. type Frontend struct { cfg Config registry *ChainRegistry root fs.FS // embedded SPA (always present) overlay fs.FS // disk overlay (nil if cfg.StaticDir not set) index []byte // resolved index.html (overlay > embedded > builtin) } // NewFrontend returns a frontend handler bound to a config and chain registry. func NewFrontend(cfg Config, r *ChainRegistry) (*Frontend, error) { root, err := fs.Sub(staticFS, "static") if err != nil { return nil, err } f := &Frontend{cfg: cfg, registry: r, root: root} dir := cfg.StaticDir if dir == "" { dir = os.Getenv("EXPLORER_STATIC_DIR") } if dir != "" { if st, err := os.Stat(dir); err == nil && st.IsDir() { f.overlay = os.DirFS(dir) } } if data := f.readStatic("index.html"); data != nil { f.index = data } else { f.index = []byte("Explorer") } return f, nil } // readStatic returns the bytes for `name` from the overlay if present, // otherwise from the embedded FS. Returns nil if neither has the file. func (f *Frontend) readStatic(name string) []byte { if f.overlay != nil { if data, err := fs.ReadFile(f.overlay, name); err == nil { return data } } if data, err := fs.ReadFile(f.root, name); err == nil { return data } return nil } // Mount installs / (SPA), /envs.js, /icon.svg, /logo.svg on mux. func (f *Frontend) Mount(mux *http.ServeMux) { mux.HandleFunc("GET /envs.js", f.handleEnvs) mux.HandleFunc("GET /icon.svg", f.handleIcon) mux.HandleFunc("GET /logo.svg", f.handleLogo) mux.HandleFunc("/", f.handleSPA) } // handleSPA serves embedded static assets and falls back to index.html for // any path the SPA owns (client-side routing). // // HEAD-method note: the bundled SPA opens EventSource (Server-Sent Events) // channels for live block / token / tx streams and pre-flights each URL // with a HEAD request: // // fetch(url, {method: 'HEAD'}).then(r => r.ok ? openEventSource() : disable()); // // If we serve a 200 (because of the SPA fallback to index.html), the SPA // proceeds to open the EventSource — which then immediately aborts because // the response body is text/html, not text/event-stream. Browser logs // "EventSource's response has a MIME type ('text/html') that is not // 'text/event-stream'" for every channel on every page load — noisy and // disables the channel anyway. // // Fix: return 404 for HEAD requests on the SPA-fallback path. Real assets // (anything in `f.root`) still serve normally on HEAD; only the index.html // fallback gets the 404 so the SSE pre-flight cleanly fails and the SPA // disables that channel on its own. Visible browser load is unchanged // because the SPA only HEAD-probes its SSE endpoints, never the SPA URL // itself. func (f *Frontend) handleSPA(w http.ResponseWriter, r *http.Request) { p := strings.TrimPrefix(r.URL.Path, "/") if p == "" { if r.Method == http.MethodHead { http.NotFound(w, r) return } f.writeIndex(w) return } // Overlay wins if it has the file (any non-directory entry); falls // back to embedded; falls back to index.html (SPA-routing). if f.overlay != nil { if file, err := f.overlay.Open(p); err == nil { st, statErr := file.Stat() file.Close() if statErr == nil && !st.IsDir() { http.ServeFileFS(w, r, f.overlay, p) return } } } file, err := f.root.Open(p) if err != nil { if r.Method == http.MethodHead { http.NotFound(w, r) return } f.writeIndex(w) return } defer file.Close() stat, err := file.Stat() if err != nil || stat.IsDir() { if r.Method == http.MethodHead { http.NotFound(w, r) return } f.writeIndex(w) return } http.ServeFileFS(w, r, f.root, p) } func (f *Frontend) writeIndex(w http.ResponseWriter) { w.Header().Set("Content-Type", "text/html; charset=utf-8") w.Header().Set("Cache-Control", "no-cache") w.Write(f.index) } // handleEnvs returns runtime config the SPA reads instead of build-time env // vars. This is what makes per-network customization possible without a // rebuild: deploy the same image, mount a different chains.yaml, get a // different brand + chain list. func (f *Frontend) handleEnvs(w http.ResponseWriter, r *http.Request) { hostBrand := f.brandForHost(r.Host) chains := f.chainListJSON() env := map[string]any{ "VITE_CHAINS": chains, "VITE_NETWORKS": f.cfg.Networks, "VITE_BRAND": hostBrand, } body, _ := json.Marshal(env) var buf bytes.Buffer buf.WriteString("window.ENV = ") buf.Write(body) buf.WriteString(";\n") w.Header().Set("Content-Type", "application/javascript") w.Header().Set("Cache-Control", "no-cache") w.Write(buf.Bytes()) } // handleIcon serves the per-host or default icon.svg from disk. func (f *Frontend) handleIcon(w http.ResponseWriter, r *http.Request) { f.serveBrandFile(w, r, func(b Brand) string { return b.IconFile }, "icon.svg") } // handleLogo serves the per-host or default logo.svg from disk. func (f *Frontend) handleLogo(w http.ResponseWriter, r *http.Request) { f.serveBrandFile(w, r, func(b Brand) string { return b.LogoFile }, "logo.svg") } // serveBrandFile resolves the file path from the matched brand (per-chain or // default) and sends it. Falls back to the on-disk overlay (if configured) // then the embedded SPA's named asset. func (f *Frontend) serveBrandFile(w http.ResponseWriter, r *http.Request, pick func(Brand) string, fallback string) { brand := f.brandStruct(r.Host) if path := pick(brand); path != "" { if data, err := os.ReadFile(path); err == nil { w.Header().Set("Content-Type", contentTypeFor(path)) w.Header().Set("Cache-Control", "public, max-age=300") w.Write(data) return } } if data := f.readStatic(fallback); data != nil { w.Header().Set("Content-Type", contentTypeFor(fallback)) w.Header().Set("Cache-Control", "public, max-age=300") w.Write(data) return } http.NotFound(w, r) } // brandForHost returns a JSON-shaped brand for /envs.js. It strips file paths. func (f *Frontend) brandForHost(host string) map[string]any { b := f.brandStruct(host) return map[string]any{ "name": b.Name, "coin": b.Coin, "accentColor": b.AccentColor, "iconUrl": b.IconURL, "logoUrl": b.LogoURL, } } // brandStruct returns the Brand for a request host: a chain whose name or // slug matches the hostname wins; otherwise the global default. // // Matches any of these hostname shapes, in order of specificity: // - "{slug}" — bare slug (curl localhost) // - "{slug}.tld..." — {slug}.lux.network, {slug}.hanzo.ai // - "explore-{slug}.tld..." — explore-hanzo.lux.network // - "api-explore-{slug}.tld..." — api-explore-hanzo.lux.network // - "explore.{slug}.tld..." — explore.hanzo.ai, explore.zoo.ngo // - "api-explore.{slug}.tld..." — api-explore.hanzo.ai // - "explore-{slug}-{env}.tld..." — explore-hanzo-test.lux.network // - "api-explore-{slug}-{env}.tld..." — api-explore-hanzo-dev.lux.network // // Per-chain Brand wins over BrandDefault; first match wins on ambiguous // hosts. func (f *Frontend) brandStruct(host string) Brand { host = strings.ToLower(strings.SplitN(host, ":", 2)[0]) for _, c := range f.cfg.Chains { if c.Brand == nil { continue } slug := c.Slug if host == slug || strings.HasPrefix(host, slug+".") || strings.HasPrefix(host, "explore-"+slug+".") || strings.HasPrefix(host, "explore-"+slug+"-") || strings.HasPrefix(host, "api-explore-"+slug+".") || strings.HasPrefix(host, "api-explore-"+slug+"-") || strings.HasPrefix(host, "explore."+slug+".") || strings.HasPrefix(host, "api-explore."+slug+".") { return *c.Brand } } return f.cfg.BrandDefault } // chainListJSON returns a SPA-friendly chain list from the live registry, // not the static config — chains added via mDNS/admin show up immediately. var chainListMu sync.Mutex func (f *Frontend) chainListJSON() []map[string]any { chainListMu.Lock() defer chainListMu.Unlock() out := []map[string]any{} if f.registry == nil { return out } for _, c := range f.registry.List() { out = append(out, map[string]any{ "slug": c.Slug, "name": c.Name, "chainId": c.ChainID, "rpc": c.RPC, "coin": c.CoinSymbol, "type": c.Type, "default": c.Default, }) } return out } // contentTypeFor maps a file extension to a Content-Type, defaulting to // application/octet-stream. func contentTypeFor(path string) string { switch strings.ToLower(filepath.Ext(path)) { case ".svg": return "image/svg+xml" case ".png": return "image/png" case ".jpg", ".jpeg": return "image/jpeg" case ".webp": return "image/webp" case ".ico": return "image/x-icon" default: return "application/octet-stream" } } // fingerprint returns a short, stable identifier for the embedded asset // bundle, useful for cache-busting log lines at startup. func fingerprint() string { root, err := fs.Sub(staticFS, "static") if err != nil { return "0" } count := 0 _ = fs.WalkDir(root, ".", func(_ string, _ fs.DirEntry, _ error) error { count++ return nil }) return fmt.Sprintf("assets=%d", count) } a x:OGif !c.Slug+".") || host == c.Slug#" Ix-G;_ P index []byte*idx, err := fs.ReadFile(root, "index.html"d<@+, index: idx}, W?embedded SPA's named asset if no // disk override is configuredfallback); err =PS D`x$;1Q/ n.  /.  P. v hx^module github.com/luxfi/explorer go 1.26.4 require ( github.com/gorilla/websocket v1.5.4-0.20250319132907-e064f32e3674 github.com/luxfi/graph v1.2.2 github.com/luxfi/indexer v1.4.5-0.20260526184203-3b72d71cc8fd github.com/luxfi/mdns v0.1.1 github.com/mattn/go-sqlite3 v2.0.3+incompatible gopkg.in/yaml.v3 v3.0.1 ) require ( filippo.io/hpke v0.4.0 // indirect github.com/beorn7/perks v1.0.1 // indirect github.com/cenkalti/backoff v2.2.1+incompatible // indirect github.com/cespare/xxhash/v2 v2.3.0 // indirect github.com/cloudflare/circl v1.6.3 // indirect github.com/dgraph-io/ristretto/v2 v2.4.0 // indirect github.com/dustin/go-humanize v1.0.1 // indirect github.com/go-chi/chi/v5 v5.3.0 // indirect github.com/go-logr/logr v1.4.3 // indirect github.com/go-logr/stdr v1.2.2 // indirect github.com/google/flatbuffers v25.12.19+incompatible // indirect github.com/google/uuid v1.6.0 // indirect github.com/gorilla/mux v1.8.1 // indirect github.com/gorilla/rpc v1.2.1 // indirect github.com/grandcat/zeroconf v1.0.0 // indirect github.com/hablullah/go-hijri v1.0.2 // indirect github.com/hablullah/go-juliandays v1.0.0 // indirect github.com/hanzoai/ltx v0.5.1 // indirect github.com/hanzoai/lz4/v4 v4.1.22 // indirect github.com/hanzoai/replicate v0.7.2 // indirect github.com/hashicorp/golang-lru/v2 v2.0.7 // indirect github.com/jalaali/go-jalaali v0.0.0-20250521085720-bf793ab67800 // indirect github.com/klauspost/compress v1.18.6 // indirect github.com/klauspost/cpuid/v2 v2.3.0 // indirect github.com/klauspost/crc32 v1.3.0 // indirect github.com/lib/pq v1.12.3 // indirect github.com/lmittmann/tint v1.1.3 // indirect github.com/luxfi/accel v1.1.9 // indirect github.com/luxfi/age v1.5.0 // indirect github.com/luxfi/cache v1.2.1 // indirect github.com/luxfi/codec v1.1.4 // indirect github.com/luxfi/compress v0.0.5 // indirect github.com/luxfi/concurrent v0.0.3 // indirect github.com/luxfi/crypto v1.19.17 // indirect github.com/luxfi/database v1.19.0 // indirect github.com/luxfi/ids v1.2.13 // indirect github.com/luxfi/log v1.4.3 // indirect github.com/luxfi/math v1.4.1 // indirect github.com/luxfi/math/big v0.1.0 // indirect github.com/luxfi/metric v1.5.8 // indirect github.com/luxfi/mock v0.1.1 // indirect github.com/luxfi/zap v0.7.0 // indirect github.com/luxfi/zapdb v1.10.0 // indirect github.com/markusmobius/go-dateparser v1.2.4 // indirect github.com/mattn/go-colorable v0.1.15 // indirect github.com/mattn/go-isatty v0.0.22 // indirect github.com/miekg/dns v1.1.72 // indirect github.com/minio/crc64nvme v1.1.1 // indirect github.com/minio/md5-simd v1.1.2 // indirect github.com/minio/minio-go/v7 v7.2.0 // indirect github.com/mr-tron/base58 v1.3.0 // indirect github.com/munnerz/goautoneg v0.0.0-20191010083416-a7dc8b61c822 // indirect github.com/ncruces/go-strftime v1.0.0 // indirect github.com/philhofer/fwd v1.2.0 // indirect github.com/prometheus/client_golang v1.23.2 // indirect github.com/prometheus/client_model v0.6.2 // indirect github.com/prometheus/common v0.68.0 // indirect github.com/prometheus/procfs v0.20.1 // indirect github.com/psanford/sqlite3vfs v0.0.0-20260519004904-f9180fa2acc9 // indirect github.com/remyoudompheng/bigfft v0.0.0-20230129092748-24d4a6f8daec // indirect github.com/rs/xid v1.6.0 // indirect github.com/tetratelabs/wazero v1.12.0 // indirect github.com/tinylib/msgp v1.6.4 // indirect github.com/wasilibs/go-re2 v1.11.0 // indirect github.com/wasilibs/wazero-helpers v0.0.0-20250123031827-cd30c44769bb // indirect github.com/zeebo/xxh3 v1.1.0 // indirect go.opentelemetry.io/auto/sdk v1.2.1 // indirect go.opentelemetry.io/otel v1.44.0 // indirect go.opentelemetry.io/otel/metric v1.44.0 // indirect go.opentelemetry.io/otel/trace v1.44.0 // indirect go.uber.org/mock v0.6.0 // indirect go.yaml.in/yaml/v3 v3.0.4 // indirect golang.org/x/crypto v0.52.0 // indirect golang.org/x/exp v0.0.0-20260529124908-c761662dc8c9 // indirect golang.org/x/mod v0.36.0 // indirect golang.org/x/net v0.55.0 // indirect golang.org/x/sync v0.20.0 // indirect golang.org/x/sys v0.45.0 // indirect golang.org/x/text v0.37.0 // indirect golang.org/x/tools v0.45.0 // indirect google.golang.org/protobuf v1.36.11 // indirect gopkg.in/ini.v1 v1.67.2 // indirect gopkg.in/natefinch/lumberjack.v2 v2.2.1 // indirect modernc.org/libc v1.72.5 // indirect modernc.org/mathutil v1.7.1 // indirect modernc.org/memory v1.11.0 // indirect modernc.org/sqlite v1.51.0 // indirect ) Szd6/xo#!*3+h0.1.0 !0.0.0-00010101000000-000000000000 0QProjectZKM/Ziren/crates/go-runtime/zkvm_runtime v0.0.0-20260215031811-a0ab0b218a8! }!decred/dcrd/dcrec/secp256k1/v4 v4`Hx2.5Areplicate v0.6T10801064154-80525e88d958A5q ib/pq v1.12Q]<0.7q ge v1`-<]ontainer v0.0.4q  database v1.17.44q ids v1.2.9q R$_ r:R!02Q! /v4 v4.9Amagefile/mage v1.1aE S4    * 2 ierrec(  t7.5A procfs v0.19I 51127171934-4e34e03a991aA Qsuperfly/ltx v0.5 2n 3^2$otel/metric v1.42$2F2 v2.4.3 crypto v0.49Z312153236-7ab1446f8b90#4 net v0.52-2 text v0.35[ 3fJA0h3[48.0 // indirect ) replace (graph => ../graphindexer => ../indexer ) "Y6~x,!{xrypto v1.17.45 =;x,1.2.01.4.1Ջ9` =V03 h1:bcqUO8twMOhHWCgN/RbjfWulVPbvUQcxDkssaRrCx4g!=/? 73/go.mod h1:ENkJ121cmDEkwQPDiKK4QhnTnW9u37PGpepbrdVcAmc!=,@?00 h1:VtH6kvZrCEjCnkHPkhExDU+GJ0ZulYX4rnA+lXJdJHw@ 70/go.mod h1:ee525i8Recbpb0jVTDZYZBr1MmvJ27OITJHZ/nlNMBw!=~A 37.44 h1:hfiTls7sqbweW+o4iaZqB8P997paC+vpgWmhN6v5MJ0!=~A :7.44/go.mod h1:6Ey5y3I0WNLHbxIlIdFqUuKfBg+b0fAgTA8FgRgQ8zg!=;geth v1.16.69 h1:CHO6xTZ+A+3itk94ts4uyVRJajNVP3RxWTjJp5qGOlIBgeth v1.16.69/go.mod h1:8eEO1hW5sa6OH2VeCMaCPnRz28JBxFvCPBCWPLsU2cI|B 00 h1:jwOXnlDGfx2TjqE5GhP5T3Rv9cGh7jHSfV6DceggmAc!=|B 70/go.mod h1:bf35zaU3Nm5tiJj1d5SoZP8DYYJl4aCVp32rOY5vj2w!=C 09 h1:+yjdhXW99drnd2Zlp1u/p8k3G23W3/1btJQ4ogHawUI!=C 79/go.mod h1:khJOEdOPxd22yn0jcVrnbX1ADa0GHn5Y74gvCzN5BYc!=C 04 h1:r/c47r6WEK+EfkTeYCj3tWKTH5dUWQauuLUmK/jDvBw!=C 4ZDICC4105612-65220f1104cd h1:s34y2+uPyyqsXuJKWQu5bL2Y1sWevkBJr2xF7eRkrFc!=C4105612-65220f1104cYDJCC4130605-aade4dd9fd4c h1:OCaB/KxgU8hrKtIBMwSoA8mt2Pf8B+23UhKQf0EbRDo!=C4130605-aade4dd9fd4cZDICC4134132-0c0ba56e32d7 h1:vgt+Q5m+lJzLLIuErWkjg2lbbKE3wtoZD9X41MoRokg!=C4134132-0c0ba56e32d7ZDR01 h1:rIfFRodb9jrD/w7KayaUk0Oc+37PaQQdKEEMJCjR8gw!=D 61/go.mod h1:64IE3xRMJcpkQwnPUfJw3pDj7wU0kRS7BZ9wM7R72jIE12.4 h1:iVz7s0gToCNUU/2cLT8gUa8MLzc0YRp4jBmeXBeKdXIE92.4/go.mod h1:i+Am9YvFsqDE75ZW8MPE62XCXGukXNiN/7mD9SKxxZY!F"E/0 h1:VB3mQcETc9j5SY1S6lAgFtuGr/rjWuDgPYnxS+OKWM FF 60/go.mod h1:/3dheKVjUk2yiS/ocH1IDzeLXOIe+kpVsErIGDOZdi F.G 01 h1:6tVarXMnNR3Xzud8FYUHjtXabTll3HI/OEqG0tgLAcI!F.G 71/go.mod h1:PkD4D4JoGuyKtfUkqPNYkrg9xKrJeNVZFdW/5XvAe/A!F H GI03 h1:yDEuuJ6bm9H8DzOzzveXI1AZlu/AeSpHNRrY1akbyc0!=@utils v1.1.3/go.mod h1:lskchZiYYRBFsSyYg3NWLPw211uRyxIs3/wAzrfSII9zap v0.2.1 h1:5uU3Z47Nu/FNcLqYeKZ4B0f+0ZDF79/2M/9FRN/1/Hw!=@zap v0.2.1/go.mod h1:CobyEg6MNO6qZ5wn3kVEw6QCxFVZvvGMnEKsC5sJZtI!=>zapdb/v4 v4.9.3 h1:KV1DrbZqtZsZvrWyPw5D8WHR0DxzqW2jHjqx6obxgoM!=zapdb/v4 v4.9.3/go.mod h1:BrpLaDeYy+smON4ASDPCFKWrQ58CXhy3WNEPGna7vuU= github.com/magefile/mage v1.14.0 h1:6QDX3g6z1YvJ4olPhT1wksUcSa/V0a1B+pJb73fBjyo= github.com/magefile/mage v1.14.0/go.mod h1:z5UZb/iS3GoOSn0JgWuiw7dxlurVYTu+/jHXqQg881A= github.com/marK04 h1:9A9LHSqF/7dyVVX6g0U9cwm9pG3kP9gSzcuIPHPsaIELL4LY/0 h1:xfD0iDuEKnDkl03q4limB+vH+GxLEtL/jb4xVJSWWELhM 60/go.mod h1:W+V8PltTTMOvKvAeJH7IuucS94S2C6jfK/D7dTCTo3LN M%R22.0 h1:T/HDJBh4ZCPbU39/+c3rRvE0uKBQlU27+QI8LJ4t64oR92.0/go.mod h1:BinMc/sQntlIE1frQmRFPUoPA1Zkr8VRgBdjWI2mNwcoRierrec0cKFw6uJDK+/gfw5BcDL0JL5aBsAFdsIT18eRtLj7VIU= github.com/pierrec/lz4/v4 v4.1.22/go.mod h1:gZWDp/Ze/IJXGXf23ltt2EXimqmTUXEy0GFuRQyBid4V@YfYF17.5 h1:pIgK94WWlQt1WLwAC5j2ynLaBRDiinoAb86HZHTUGIZCommon v0.67.5/go.mod h1:SjE/0MzDEEAyrdr5Gqc6G+sXI67maCxzaT3A2+HqjUw\"319.2 h1:zUMhqEW66Ex7OXIiDkll3tl9a1ZdilUOd/F6ZXw4Vws\":19.2/go.mod h1:M0aotyiemPhBCM0z5w87kL22CxfcH05ZpYlu+b4J7mw]]+G51127171934-4e34e03a991a h1:r4YWl0uVObCbBFvj1VsIlyHzgZwZOHvY1KdRaQjzzUc]]+51127171934-4e34e03a991a]~abPsuperfly/ltx v0.5.1 h1:vGUeBhKvBKZ2s2TsTrOSahz+m0PswfqOWDAD+ICiiYY= github.com/superfly/ltx v0.5.1/go.mod h1:Nf50QAIXU/ET4ua3AuQ2fh31MbgNQZA7r/DYx6Os77s9d#22.1 h1:J4X2hrGzJvt+wqltuvcSjHQ7ujQxA9gb6PeMs4qlUWs9d#92.1/go.mod h1:wYx2gNRg8/WihJfSDxA1TIL8H+GkfLYm+bIfbblu9VQe 23.0 h1:LFhBNzoStM3wMie6rN2slD1cuYH2CGiHpvNL3UtcsMwe 93.0/go.mod h1:AafrCXVvGRJJOImMajgJ2M7rVmWyisVK7sFshbxnVrge?nottinygc v0.4.0 h1:h1TJMihMC4neN6Zq+WKpLxgd9xCFMw7O9ETLwY2exJQeFnottinygc v0.4.0/go.mod h1:oDcIotskuYNMpqMF23l7Z8uzD4TC0WXHK8jetlB3HIo!hi22.0 h1:lSQGzTgVR3+sgJDAU/7/ZMjN9Z+vUip7leaqBKy4shoiBotel v1.42.0/go.mod h1:lJNsdRMxCUIWuMlVJWzecSMuNjE7dOYyWlqOXWkdqCci*l12.0 h1:2jXG+3oZLNXEPfNmnpxKDeZsFI5o4J+nz6xUlaFdF/ i*l92.0/go.mod h1:RlUN/7vTU7Ao/diDkEpQpnz3/92J9ko05BIwxYa2SSIi8m22.0 h1:OUCgIPt+mzOnaUTpOQcBiM/PLQ/Op7oq6g4LenLmOYYi8m92.0/go.mod h1:f3K9S+IFqnumBkKhRJMeaZeNk9epyhnCmQh/EysQCdcmL03 h1:6gvOSjQoTB3vt1l+CU+tSyi/HOjfOjRLJ4YwYZGwRO0n63/go.mod h1:zSxWcmIDjOzPXpjlTTbAsKokqkDNAVtZO0WOMiT90sqop p349.0 h1:+Ng2ULVvLHnJ/ZFEq4KdcDd/cfjrrjjNSXNzxg0Y4U4q:49.0/go.mod h1:ErX4dUh2UM+CFYiXZRTcMpEcN8b/1gxEuv3nODoYtCAqE312153236-7ab1446f8b90 h1:jiDhWWeC7jfWqR9c/uplMOqJ0sbNlNWv0UkzE0vX1MAqL312153236-7ab1446f8b90/go.mod h1:xE1HEv6b+1SCZ5/uscMRjUBKtIxworgEcEi+/n9NQDQrHrn24.0 h1:xIHgNUUnW6sYkcM5Jleh05DvLOtwc6RitGHbDk4akRIr94.0/go.mod h1:ykgH52iCZe79kzLLMhyCUzhMci+nQj+0XkbXpNYtVjYtWs22.0 h1:He/TN1l0e4mmR3QqHMT2Xab3Aj3L9qjbhRm78/6jrW0t952.0/go.mod h1:R1MAz7uMZxVMualyPXb+VaqGSa3LIaUqk0eEt3w36S|u96.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITgw342.0 h1:omrd2nAlyT5ESRdCLYdm3+fMfNFE/+Rf4bDIQImRJeow42x25.0 h1:JOVx6vVDFokkpaq1AEptVzLTpDe9KGpj5tR4/X+ybL8x95.0/go.mod h1:khi/HExzZJ2pGnjenulevKNX1W67CUy0AsXcNubPGCAy!23.0 h1:12BdW9CeB3Z+J/I/wj34VMl8X+fEXBxVR90JeMX5E7sz83.0/go.mod h1:uHkMso649BX2cZK6+RpuIPXS3ho2hZo4FVwfoy1vIk{26.0 h1:5+ul4Swaf3ESvrOnidPp4GZbzf0mxVQpDCYUQE7OJfkk|96.0/go.mod h1:fef3am4MQ93R2HHpKnLk4/Tbh/s0+wqD5nfa6Pnwy4E}Ńē27.1 h1:9W30zRlYrefrDV2JE2O8VDtJ1yPGownxciz5rrbQZis97.1/go.mod h1:uVtb5OGqUKpoLWhqwNQo/8LwvoiEBLvZXIQ/SmO6mL022.0 h1:hjG66bI/kqIPX1b2yT6fr/jt+QedtP2fqojG2VrFuVw92.0/go.mod h1:6F08EBCx5uQc38kMGl+0Nm0oWczoo1c7cgpzEry7Uc0Q02 h1:ZtDCnhonXSZexk/AYsegNRV1lJGgaNZJuKjJSWKyEqo.2H0.0 h1:U58NawXqXbgpZ/dcdS9kMshu08aiA6b7gusEusqzNkw= modernc.org/libc v1.70.0/go.mod h1:OVmxFGP1CI/Z4L3E0Q3Mf1PDE0BucwMkcXjjLntvHJoω4J1.4 h1:2kNGMRiUjrp4LcaPuLY2PzUfqM/w9N23quVwhKt5Qm8= modernc.org/opt v0.1.4M348.0 h1:ElZyLop3Q2mHYk5IFPPXADejZrlHu7APbpB0sF78bq4m:48.0/go.mod h1:hWjRO6Tj/5Ik8ieqxQybiEOUXy0NJFNp2tpvVpKlvig87sx@B B"AR$!xHA?/1 h1:6NXqd1aDXvhIN13U0O3UvehDjG/9fQ0tb+w8ZpTjWs>? 1u@uAc Ax=0 > >wxYnM=ńwD`X$n)ǵa$9Hf؇';Cnܹ{gR'er" _ԕiT4B]UlU-J݌MS6-|.fiY>^d%f Xe^T6<ֵUSeHUM΍rVŃUVsLebV ݑ=VtR%?*`LRf[2R=˯eb:-aql:/7j/{yϲ:̳v<)p&O:1v#H8r#8mӼrV+mjj+ IQ˲*(+ɲvmz:SWE^Z,`8[`Z*}ݨܪ4)S]:eȨìꮲѐ1P`s $<%v|)Jd_!~-e;4 E0#(;u]TFv O 4=ez`)ΆsaYsl?ݝqcMDE53#S qL3ď 0v|<>F6(< cUd(̜,Öx RkSMQi$'DҊo.訍u,Q'tD{tjj@ vQxQp%J#k]fD F~NضХ3id'kTXQfY=#QAA`uIe7>C;Kmr$fJDJT)1 ƎHsvY#52ʪy#Ù)+x^8XNB= 4 9J|Z{LpxgXb F-zLw#~+c~GTB)!0`B=z cbS㋛VT c`>:{<Ev.頥x z{%,iտ fv[_D2ЖMZ58JN_ :H.L/_ zNGB Bŭ"A3مG'pD-U# 39ɤ.iWhCq"I8h'FTuID88;GZ:0>R,KT,;o"䶮JxW^TҷIGHVRAZ-dN1:`0,V.UH}E"ۡ&ñiXw.RDN"_u +ѽHg<^ \.BQQ}ָ#us$ 6pRԶ#}_Z@Y"pH `wKK5,lUp8!K.||qZCjtGHg U3Րi6-!Nz-hb/s$f#wimFxOq@Co,dCɫ.}T3(ӘL1GP}P\HZgh֑Sa%; (/:ȵ"N/RNt5+ZU6*wCǃ㳓4L0[N/io2TdF"~3Y u/~;Ճ xu263 A.l 9+r0 bΥoYVk Z ! _Q-$^[^nDJNk(luð+!&U8d&@F䘼 Vo?JmL㛵$ay4$Y>Iw&-8In[+NFAȁ'r2=ST 1pQx'abZy1E̻'QyH<_&ri/9ydBP GOsGyw8* 4JRyieI 36o%i ٧S8+/쨡g:`ԆWfs2 !~F?vB'9菀i#=}FsUsQ;}Jsu)ԨXT(XLKȃ]s[SBuDE)m`.ſ%qAIo6j7 lབྷ>QTg(JOQ80Uc kV0J׬fmlmDZ% {6Zȴm!]A`߃:,P:WQ5>yVۛmM:@RɆ/w]d4~tkQ GJTc[o|{hD|ZQG8hWGzrb%jx68ZynRqIy8b\CזE esv.&,$Hf7J%4C~l}y(Ե[I!51fAlon$W±Lj|Yް 0)K;:Wr~! {fk8%Cn٧Jj=!%2kS!wF6Ry 8mnx|d}•Ҹr-&P8PFSP.z/#5+:r?xx]u7up]tX4A|#Wx@KF'Y{N[L{V3M,[Jv/I";]aֶQOJ` mRE&&[KLhR;Hz{U2R}'NeB j޴r g-5Joq嵰PlQ?P!X "dMT@j!ΖE5z943 A S3%6X,6<(s?e3HKȠҡ|fUA/L5$A( Q%q0q8iȅ 4R=hÂ#S[ۯITt<{FⓈzӆ2hPGLԡd;7 aK*l#9hfI*j^",M&k-o8C >w;~bD3hw/U+7zt;mSW_h^4=ĺ:1Ş ׌l1kWb,tQV/on;B+c9oLu2#jw-1 ^&c+7^sa[1C^Effͣs &T봩7O>0n{fQ0Cb LZ̹H渳d,s ( dnO;I]#O@CE z&f{J,h%!P}䣢} %lCx VUnX &Ex7Apackage main import ( "context" "database/sql" "encoding/json" "fmt" "log" "net/http" "os" "path/filepath" "strings" "sync" "time" _ "github.com/mattn/go-sqlite3" "github.com/luxfi/graph/engine" graphidx "github.com/luxfi/graph/indexer" graphstor "github.com/luxfi/graph/storage" "github.com/luxfi/indexer/evm" "github.com/luxfi/indexer/explorer" idxstor "github.com/luxfi/indexer/storage" ) // ChainSupervisor owns the per-chain indexer + graph goroutines plus the // route dispatcher that maps /v1/indexer/{slug}/* and /v1/graph/{slug}/* // requests to the correct handler. Routes are mutable at runtime: adding a // chain spawns its workers, removing a chain cancels them. type ChainSupervisor struct { dataDir string mu sync.Mutex state map[string]*chainState indexerRoutes sync.Map // map[slug]http.Handler graphRoutes sync.Map // map[slug + "/" + subgraph]http.Handler defaultSlug string // serves /v1/indexer/* (no slug prefix) // realtimeHub is the explorer's RealtimeHub. When set (via // AttachRealtime), the supervisor wires each per-chain EVM indexer's // Subscriber.OnBroadcast callback so block events flow into the hub // → out to WebSocket + SSE subscribers. Nil = no live broadcast. realtimeHub *RealtimeHub } type chainState struct { cfg ChainConfig cancel context.CancelFunc wg sync.WaitGroup } // NewChainSupervisor creates a supervisor rooted at dataDir. func NewChainSupervisor(dataDir string) *ChainSupervisor { return &ChainSupervisor{ dataDir: dataDir, state: make(map[string]*chainState), } } // AttachRealtime wires per-chain block events into the explorer's // RealtimeHub. Called once from main.go after both the supervisor and // the registry's hub exist. Subsequent chain spawns (runChain below) // install the Subscriber.OnBroadcast callback automatically. func (s *ChainSupervisor) AttachRealtime(h *RealtimeHub) { s.realtimeHub = h } // MountRoutes installs the /v1/indexer and /v1/graph dispatchers on mux. The // dispatchers look up per-chain handlers from the supervisor's route maps so // chains added at runtime become reachable without re-mounting. func (s *ChainSupervisor) MountRoutes(mux *http.ServeMux) { mux.Handle("/v1/indexer/", http.HandlerFunc(s.dispatchIndexer)) mux.Handle("/v1/explorer/", http.HandlerFunc(s.dispatchExplorerLegacy)) mux.Handle("/v1/graph/", http.HandlerFunc(s.dispatchGraph)) } // SetDefaultSlug picks which chain serves the unprefixed /v1/indexer/* route. func (s *ChainSupervisor) SetDefaultSlug(slug string) { s.mu.Lock() s.defaultSlug = slug s.mu.Unlock() } // start spawns workers for cfg. Idempotent: starting an already-running slug // is a no-op. func (s *ChainSupervisor) start(cfg ChainConfig) { s.mu.Lock() if _, ok := s.state[cfg.Slug]; ok { s.mu.Unlock() return } ctx, cancel := context.WithCancel(context.Background()) st := &chainState{cfg: cfg, cancel: cancel} s.state[cfg.Slug] = st if cfg.Default && s.defaultSlug == "" { s.defaultSlug = cfg.Slug } s.mu.Unlock() st.wg.Add(1) go func() { defer st.wg.Done() s.runChain(ctx, cfg) }() if cfg.Graph.Enabled { for _, sg := range cfg.Graph.Subgraphs { if !sg.Enabled { continue } sg := sg st.wg.Add(1) go func() { defer st.wg.Done() s.runSubgraph(ctx, cfg, sg) }() } } } // stop cancels and waits for all workers belonging to slug. func (s *ChainSupervisor) stop(slug string) { s.mu.Lock() st, ok := s.state[slug] if !ok { s.mu.Unlock() return } delete(s.state, slug) if s.defaultSlug == slug { s.defaultSlug = "" } s.mu.Unlock() st.cancel() st.wg.Wait() s.indexerRoutes.Delete(slug) s.graphRoutes.Range(func(k, _ any) bool { if key, ok := k.(string); ok && strings.HasPrefix(key, slug+"/") { s.graphRoutes.Delete(k) } return true }) log.Printf("[supervisor] stopped %s", slug) } // Wait blocks until ctx is done, then cancels every chain and waits for // goroutines to drain. func (s *ChainSupervisor) Wait(ctx context.Context) { <-ctx.Done() s.mu.Lock() slugs := make([]string, 0, len(s.state)) for k := range s.state { slugs = append(slugs, k) } s.mu.Unlock() for _, slug := range slugs { s.stop(slug) } } // runChain runs one chain's indexer to completion or context cancel and then // mounts the standalone explorer API once the SQLite schema is ready. func (s *ChainSupervisor) runChain(ctx context.Context, cfg ChainConfig) { chainDir := filepath.Join(s.dataDir, cfg.Slug) if err := os.MkdirAll(chainDir, 0755); err != nil { log.Printf("[%s] mkdir: %v", cfg.Slug, err) return } store, err := idxstor.NewUnified(idxstor.DefaultUnifiedConfig(chainDir)) if err != nil { log.Printf("[%s] storage: %v", cfg.Slug, err) return } defer store.Close() if err := store.Init(ctx); err != nil { log.Printf("[%s] storage init: %v", cfg.Slug, err) return } dbPath := filepath.Join(chainDir, "query", "indexer.db") log.Printf("[%s] indexing %s (%s) -> %s", cfg.Slug, cfg.Name, cfg.CoinSymbol, dbPath) go s.mountIndexerAPI(ctx, cfg, dbPath) switch cfg.Type { case "", "evm": poll := 30 * time.Second if cfg.Indexer.PollInterval != "" { if d, err := time.ParseDuration(cfg.Indexer.PollInterval); err == nil { poll = d } } idx, err := evm.NewIndexer(evm.Config{ ChainName: cfg.Name, ChainID: cfg.ChainID, RPCEndpoint: cfg.RPC, HTTPPort: 0, PollInterval: poll, StartBlock: cfg.Indexer.StartBlock, }, store) if err != nil { log.Printf("[%s] evm indexer: %v", cfg.Slug, err) return } // Live broadcast bridge — when the supervisor has been given a // RealtimeHub (see AttachRealtime), every block the indexer // commits is re-published into the hub on the chain's slug. The // hub then fans out to WebSocket and SSE subscribers (see // realtime.go + realtime_sse.go). slug captured by value so the // closure doesn't see a mutated `cfg` if the supervisor loops. if s.realtimeHub != nil && idx.Subscriber() != nil { slug := cfg.Slug hub := s.realtimeHub idx.Subscriber().OnBroadcast = func(eventType string, data any) { hub.Broadcast(eventType, slug, data) } } if err := idx.Init(ctx); err != nil { log.Printf("[%s] evm init: %v", cfg.Slug, err) return } if err := idx.Run(ctx); err != nil && ctx.Err() == nil { log.Printf("[%s] evm run: %v", cfg.Slug, err) } default: log.Printf("[%s] %s indexer: passive (no chain-specific implementation)", cfg.Slug, cfg.Type) <-ctx.Done() } } // mountIndexerAPI waits for the per-chain SQLite schema to settle, then // publishes the standalone explorer API in the indexer/explorer route maps. func (s *ChainSupervisor) mountIndexerAPI(ctx context.Context, cfg ChainConfig, dbPath string) { apiPrefix := "/v1/indexer/" + cfg.Slug deadline := time.Now().Add(5 * time.Minute) for { select { case <-ctx.Done(): return case <-time.After(time.Second): } if _, err := os.Stat(dbPath); err != nil { if time.Now().After(deadline) { log.Printf("[%s] api waiting for %s: %v", cfg.Slug, dbPath, err) deadline = time.Now().Add(5 * time.Minute) } continue } if cfg.Type == "" || cfg.Type == "evm" { db, err := sql.Open("sqlite3", "file:"+dbPath+"?mode=ro") if err == nil { var n int _ = db.QueryRow("SELECT COUNT(*) FROM sqlite_master WHERE type='table' AND name='evm_blocks'").Scan(&n) db.Close() if n == 0 { if time.Now().After(deadline) { log.Printf("[%s] api waiting for evm_blocks", cfg.Slug) deadline = time.Now().Add(5 * time.Minute) } continue } } } srv, err := explorer.NewStandaloneServer(explorer.Config{ IndexerDBPath: dbPath, ChainID: cfg.ChainID, ChainName: cfg.Name, CoinSymbol: cfg.CoinSymbol, APIPrefix: apiPrefix, }) if err != nil { if time.Now().After(deadline) { log.Printf("[%s] api: %v", cfg.Slug, err) deadline = time.Now().Add(5 * time.Minute) } continue } s.indexerRoutes.Store(cfg.Slug, srv.Handler()) log.Printf("[%s] api mounted at %s/*", cfg.Slug, apiPrefix) return } } // runSubgraph spawns a graph indexer + engine for a single subgraph and // publishes its handler at /v1/graph/{chain-slug}/{subgraph-name}/. func (s *ChainSupervisor) runSubgraph(ctx context.Context, cfg ChainConfig, sg Subgraph) { dir := filepath.Join(s.dataDir, cfg.Slug, "graph", sg.Name) if err := os.MkdirAll(dir, 0755); err != nil { log.Printf("[%s/%s] mkdir: %v", cfg.Slug, sg.Name, err) return } store, err := graphstor.New(dir) if err != nil { log.Printf("[%s/%s] storage: %v", cfg.Slug, sg.Name, err) return } defer store.Close() if err := store.Init(ctx); err != nil { log.Printf("[%s/%s] storage init: %v", cfg.Slug, sg.Name, err) return } idx := graphidx.New(cfg.RPC, store) go func() { if err := idx.Run(ctx); err != nil && ctx.Err() == nil { log.Printf("[%s/%s] indexer: %v", cfg.Slug, sg.Name, err) } }() eng := engine.New(store, &engine.Config{ MaxQueryDepth: 10, MaxResultSize: 1 << 20, QueryTimeoutMs: 30000, }) schema := sg.Schema if schema == "" { schema = "amm" } if err := eng.LoadBuiltin(schema); err != nil { log.Printf("[%s/%s] schema %q: %v", cfg.Slug, sg.Name, schema, err) return } prefix := fmt.Sprintf("/v1/graph/%s/%s", cfg.Slug, sg.Name) mux := http.NewServeMux() gqlHandler := func(w http.ResponseWriter, r *http.Request) { r.Body = http.MaxBytesReader(w, r.Body, 10<<20) var req engine.Request if err := json.NewDecoder(r.Body).Decode(&req); err != nil { http.Error(w, `{"errors":[{"message":"invalid JSON"}]}`, http.StatusBadRequest) return } resp := eng.Execute(r.Context(), &req) w.Header().Set("Content-Type", "application/json") json.NewEncoder(w).Encode(resp) } statusHandler := func(w http.ResponseWriter, r *http.Request) { w.Header().Set("Content-Type", "application/json") st := idx.Status() fmt.Fprintf(w, `{"status":"ok","block":%d,"indexed":%d}`, st.LatestBlock, st.IndexedEvents) } mux.HandleFunc("POST "+prefix+"/graphql", gqlHandler) mux.HandleFunc("GET "+prefix+"/graphql", eng.HandleGraphiQL) mux.HandleFunc("POST "+prefix+"/ql", gqlHandler) mux.HandleFunc("GET "+prefix+"/ql", eng.HandleGraphiQL) mux.HandleFunc("GET "+prefix+"/health", statusHandler) s.graphRoutes.Store(cfg.Slug+"/"+sg.Name, http.Handler(mux)) log.Printf("[%s/%s] graph mounted at %s/{graphql,ql,health} (schema=%s)", cfg.Slug, sg.Name, prefix, schema) <-ctx.Done() } // dispatchIndexer routes /v1/indexer/{slug}/* and /v1/indexer/* (default // chain) to the per-chain handler installed by mountIndexerAPI. // // Edge case the older code got wrong: when the first path segment matches // the slug regex but is NOT a registered chain (e.g. `main-page` in // `/v1/indexer/main-page/blocks`), splitSlug peels it off as a "slug" and // the dispatcher then forwarded only the REMAINING segments to the // default chain. That turned `/v1/indexer/main-page/blocks` into // `/v1/indexer/evm/blocks` server-side — a completely different endpoint // with a different response shape (paginated envelope vs. raw array). The // SPA's `?.slice(0,8)` on the home page's Latest Blocks widget tripped // over the envelope and threw "o.slice is not a function". // // Fix: when the parsed slug isn't a real chain, re-join it with the rest // before delegating, so the unrecognized segment is preserved as part of // the path under the default chain. func (s *ChainSupervisor) dispatchIndexer(w http.ResponseWriter, r *http.Request) { slug, rest, ok := splitSlug(r.URL.Path, "/v1/indexer/") if !ok { s.serveDefault(w, r, "") return } if h, found := s.indexerRoutes.Load(slug); found { h.(http.Handler).ServeHTTP(w, r) return } fullTail := slug if rest != "" { fullTail = slug + "/" + rest } s.serveDefault(w, r, fullTail) } // serveDefault forwards an unprefixed /v1/indexer/* request to the default // chain. The standalone server is mounted under its slug, so we rewrite the // URL to include the slug before delegating. func (s *ChainSupervisor) serveDefault(w http.ResponseWriter, r *http.Request, rest string) { s.mu.Lock() def := s.defaultSlug s.mu.Unlock() if def == "" { http.Error(w, `{"error":"no default chain"}`, http.StatusNotFound) return } h, ok := s.indexerRoutes.Load(def) if !ok { http.Error(w, `{"error":"chain not ready"}`, http.StatusServiceUnavailable) return } r2 := r.Clone(r.Context()) r2.URL.Path = "/v1/indexer/" + def + "/" + strings.TrimPrefix(rest, "/") h.(http.Handler).ServeHTTP(w, r2) } // dispatchExplorerLegacy preserves the older /v1/explorer/{slug}/* prefix // for clients that haven't migrated to /v1/indexer/. func (s *ChainSupervisor) dispatchExplorerLegacy(w http.ResponseWriter, r *http.Request) { slug, rest, ok := splitSlug(r.URL.Path, "/v1/explorer/") if !ok { http.NotFound(w, r) return } h, found := s.indexerRoutes.Load(slug) if !found { http.NotFound(w, r) return } r2 := r.Clone(r.Context()) r2.URL.Path = "/v1/indexer/" + slug + "/" + strings.TrimPrefix(rest, "/") h.(http.Handler).ServeHTTP(w, r2) } // dispatchGraph routes /v1/graph/{slug}/{subgraph}/* to the matching engine. func (s *ChainSupervisor) dispatchGraph(w http.ResponseWriter, r *http.Request) { rest := strings.TrimPrefix(r.URL.Path, "/v1/graph/") if rest == r.URL.Path { http.NotFound(w, r) return } parts := strings.SplitN(rest, "/", 3) if len(parts) < 2 { http.NotFound(w, r) return } key := parts[0] + "/" + parts[1] h, ok := s.graphRoutes.Load(key) if !ok { http.NotFound(w, r) return } h.(http.Handler).ServeHTTP(w, r) } // splitSlug returns the chain slug and the remainder of the path after a // known prefix (e.g. "/v1/indexer/"). Returns ok=false if the path does not // match the prefix or contains no slug. func splitSlug(path, prefix string) (slug, rest string, ok bool) { if !strings.HasPrefix(path, prefix) { return "", "", false } tail := strings.TrimPrefix(path, prefix) if tail == "" { return "", "", false } parts := strings.SplitN(tail, "/", 2) if !slugPattern.MatchString(parts[0]) { return "", "", false } if len(parts) == 1 { return parts[0], "", true } return parts[0], parts[1], true } lLx ooClR"%yx!oh)s3,".rest?.V Q /xh^> ns @x31̒$^l-mϔSPQC3T5_qv^?pW¡9n34⪗,|@_OuןMgF'ge2HJ./%a5|<]]جbUtҔ?f(sY({@vׯ{=&L/H^QejLy׋gPA.`wzg4mbmI^~&}ˁ*JH+KH-IիLaص}[|vohfe,~7Ly~nA~1PPكr_h/2P,2NWsԩ808QJWԼ2za":c+"cօДŗsg⠖3uJUJjrS-^B ˱"ȪK.W+H⊔^N#CY1-UJ9~|CZm񥍿zB/(ہt"G=sb|xY8 `iEiUIߞQ)$YE~\']Kɵ3إ, ՆӱZ@\9̐B670X0J_a>4W12 lqs4^1_ɬKpGTow_ħ-n;Mt-JpaU&e&xnIE/̐E&Un&l^Ob0vb:CJӂC)}2FِpBl ?b xHyF+w`:m6 >%.^ & 3QRN :rfdO:d@IϐP"'kOeDc ufQ' g@wqd㠋TЫWK3a0 $+w~tmZS:#i0g7oue'"aܤW2yxêUR%[vFu:eoFo>6xMFx X# explorer **Org:** luxfi · **Ecosystem:** lux · **Path:** `/Users/a/work/lux/luxfi/explorer` **Origin:** https://github.com/luxfi/explorer.git ## Discovery This file (`CLAUDE.md`) is the canonical agent-facing readme; `LLM.md` is a symlink to it. Update either name and both stay in sync. ## Where to look first - `README.md` — human-facing overview (if present) - `package.json` / `Cargo.toml` / `pyproject.toml` / `go.mod` — language & deps - `.github/workflows/` — CI surface - `docs/` — extended docs (if present) ## Sibling repos See the org-level `LLM.md` at `/Users/a/work/lux/luxfi/LLM.md` for the full inventory of sibling repos and inter-repo dependencies. ## Unified explorer bundle (2026-06-05) luxfi/explorer + luxfi/graph + luxfi/explore are rolled into ONE Deployment per env. Architecture: - **luxfi/explorer (this repo)** — the Go binary `cmd: explorer`. Imports `github.com/luxfi/indexer` and `github.com/luxfi/graph` as libraries. Serves on `:8090`: /v1/indexer/{slug}/* — Blockscout-compatible JSON API /v1/graph/{slug}/{subgraph}/ — GraphQL per-chain per-subgraph /v1/explorer/admin/* — Runtime chain registry CRUD /v1/explorer/realtime — WebSocket + SSE live feed / — Embedded SPA shim (fallback only) Image: `ghcr.io/luxfi/explorer:1.2.18` - **luxfi/explore** — the Next.js SSR app (Blockscout fork). Serves the rich SPA at `:3000`. Runs as a **sidecar container in the same Pod**; shares the network namespace with the explorer Go binary so it can hit `http://localhost:8090` for data if needed (currently it uses the public `api-explore..network` host). Image: `ghcr.io/luxfi/explore@sha256:ddb15bc28ff38c7619bc08df9337e02b32ef886c33b9993a9b9cb3c475ad75de` - **luxfi/graph (formerly graphd)** — NOT a separate Deployment. Linked into the explorer binary as a library. Per-chain GraphQL engines are spawned by the supervisor when `chains[].graph.enabled: true` in the chains.yaml ConfigMap. The legacy `lux-indexer` Deployment (same Go `indexerd` binary, only indexed EVM) has been **deleted**. Its routes are served by the unified explorer Deployment. Per env: 1 Pod, 2 containers, 1 Service exposing `:80 / :8090 / :3000`. Manifests: ~/work/lux/universe/k8s/lux-mainnet/explorer.yaml ~/work/lux/universe/k8s/lux-mainnet/explore-ingress.yaml ~/work/lux/universe/k8s/lux-testnet/explorer.yaml ~/work/lux/universe/k8s/lux-testnet/explore-ingress.yaml ~/work/lux/universe/k8s/lux-devnet/explorer.yaml ~/work/lux/universe/k8s/lux-devnet/explore-ingress.yaml Public URLs (all 200 OK, verified 2026-06-05): https://explore.lux.network (Next.js SPA) https://api-explore.lux.network/v1/indexer/cchain/blocks https://api-explore.lux.network/v1/graph/cchain/amm/graphql https://explore.lux-test.network (Next.js SPA) https://api-explore.lux-test.network/v1/indexer/cchain/blocks https://api-explore.lux-test.network/v1/graph/cchain/amm/graphql https://explore.lux-dev.network (Next.js SPA) https://api-explore.lux-dev.network/v1/indexer/cchain/blocks https://api-explore.lux-dev.network/v1/graph/cchain/amm/graphql *Lr]xuOQ#G[J[(t j@0*b|vڎvJ_h4/ H\7qɂ@ݙac#-lvu=st}l)Ib2`|rR $Dž8Eecl.AQqa2%R,L s5lg)EPeĤtX%1QfC@,KQƗSn j=*}&JM1AuPUzS [c U*]~^S WKCjJLRQ2m*5QV]Bc2]E)JBf̀ll@va_;뀁>L. 19 TB?9 ǍuDՅ&q nFR;.uN˼Ȧ EX`w=-hItKT\h*j؏# 6?!CbǠp=񃳍M~)EpQl g\0`TKF!f.¡̌Y ; {gאMl<-4'Р+}Jy% ~(_HIkɺÇ8|%n]bRB ,xDLx;KwNF"ϭ|QgF9Fɂ0 M~xhE^) OΒ>dVX8'`G Ηfg4IgꇈHyғ1oV`f|Sj/;+<̉驓9&of|{`A"ܲ xX'KvOg63,H:lKx^gfsd. x[vۨl';N_~;q,%x)};)^;jТE]@R85Phtp@Q E>E5>) %Ik'{-q-l|cr1e7gő/< ='(J7*=Zv }| 4wBGO=,O7zBQ+܆H[.v'"gY$m%#.%|N^mvZJ9=MhM-:Eɗy~Sy  CC 8D1A9 l /K*Uf8`$_o*/+s$**£LHA"@N~_AFX}O1}-7ƾ4ާB8lj1bbĹ3_}gkg'w=+8ZVI"3-*;`Ł0UVHn,H){t';xeI>oB=$Ei`GuUKWlKgEfT0z~X5˼hͺ ZZumf:$-`_djvveߚKk e_֞uBCqjEݢO,݃%u֓a5)K{7IZ~<~%}iq{(UÞ4k1461i\XU1OuQъhY[QPg0rΉ-D db+m*:ZkTgͿuC΢Aub$y(2gC2J5D|(8AT}hyEV`%Q]>ܝ;5]*|  APy@Q:~2nSty^ }Ia@&yQ},[3 t~fg*ne3/" k%( +^Nbj&GQ_f(Llb<6^W (Ks{~o&rhw%x|4(姙w+z' v%=LSC ̕a\É &Fcu, }oy֔Y6Uu&7ԇve-I uqSG-*lb8r ȉn^_Fww]Ѹ$B^K[tJU>S v$k1[^ ؑq^Q}2gF~QН.GdIIQhFC퉏SUח,o .p #yVQ6OYjXSrYPV{/Kdd+֫okz~EG !AYF/mֺvػ[Nje`|6H$cQ7̊=O ۱*r#r+1f j%i=lKR ov3#7RUJ9OT.)Oq lp u>MI pW'o>D\v&;8`ќ,awu X![3Ua?zGiȦUpuA/g,%yDӄҐ{vkjڻ=(8*e*{[_ٶVf=S#i u0j4C:4eSʈN N#s!n~9.||F$T (Zf!BfAmyFn_I`4z/a1}m/M#B숅gI NyB}9#,gG7x.ү͙@Ú2"li*ܐ8~Xm"+xJKbN6;N~NLӽ=A3&?[.jbbQQY t|3bCg/ΡU"܋$ve]ѡ·Z  P }q9_> qbЏ+ nj 7~4VSo=sYE:Nِei׼5lN&?s\c'.s ]f葇߯׳*Ivh I(8ӥO<{p?-$Da\бA{0 NfbʊkX x~?C׊M` *aQ>d:OqU±[72ҩ_G"K 86Z_+l;y_ާF!P^(ϱk\tL,TWozrNitp\A12Fjijr[<2qG#9. "/(#8y5sP+CSh;@1Z+wmS^pX6ǖmtwgWM*43~ k[lv Uj* L' VHǶ3^lӤeUCUƟR+MuVfR ɒ9EG L jql'{!^u[6^y hj2ucu[r[unCy6hy4hlv+7񬪺"'M Q@E.eM;+<,.if֔&nsS1Xp"{#.*rFfFutc gMK\ ;\\O3}*^3E_.ܳ1'bhXt*)\16Mtb ؎n? AS }8FHe%EN>NJKĆ]M̩)$NKȱnM2|@_eS5fR +&gȓcqb YR6-KI˔ވ(A}Hp]Nj~3^JHUJd9I2Ĥ&빽n}L(~g__TNKϷK,µ8\GˢvHt 9ɊlG?+K-c9j,Yu rJof"?lnSpmOysƙFUhڣfKnj+2hMH>WjI+P1}Zȹ.m$wiHCFYRX; P3>kBMK6pnXmvSby4mz=~lpdv̚5BQn!wأ ¼#+KAaV߬2;a +|E((=6L|g1Պ?V..B#sJx83U5G[3b?9|y_Έ88BBܫ!2KfNԳ!ݶ)lWl[7`|V$z4aYJX78'l{dR-Ru Ϸ"l 84"3DE؆%a;RϮ]z-l6%צ.[|Sb,ۓRQ^FGA(@0rq gJg9xQ5u)̔L'3Wg󌠺fݏi ! 1&P,ϷI^cGT`]Y$0 @[zN ~ĺT3Gb@&DbiЈ?['a+C]J \`hN}J?L2YN2ພBٸ<~ A@%`š(s|'su9Ҥ,{X5![@N. ur9ZkIy5=g Gbǚvjz;]3Mh!6%yW\] 888lScCOS2F, O4Sη IqrQfޢv^fl9XV|ډ.CHpKzi%iφ+Qݲc<.B,.3.9P+z] a5E;f=74Kޝ9 KXB^Úg4NYRӹ߰ ekK oy[ &2Vvl6y50/?{&VF2{Iů?*@EaV@\Z qd2H2lW?"]u~*緍Q c`>A٤Au'gkPҐk{dF(5Y}Bvyz{EkdWV/Z |r,dޝd+Qĉq>x d8a9T|G48Um῕YPEB>qX$#n%rjfWaZw6NC [ϟČLN= ~q+5Nf CWԝNTT-]uiƪϼEjO,UHE΃P>$4I-XRxDe#IrSaG sدNxmDꇇԢᰖ#~3'ɛår0تIj[!nvD_/xCr/p̖.qq<7҂4b>^4mj˾XuˍO@9p1E}|<(zTЖ ŜZJcȆlv].׻0 R^\ا|B̹oјBH{nP՛. `ۀnfD噃[*3\"Jr ?2`mZEI [_[tknMy9[_kyv1(|W/ ,hgҫ=☛~> riNTѝEemUc #)6a1Rڬ&;GnUZU6/VRp(&y^0ay4Ic^ DQbPTk``CX G{mM{@U5Џoq!zqt"Vl3"T02O}4GȻ<^fȂNu3X̑Ⱦ >4-f=nGD1M/ Y7s@\ln?*(B,lRrWe/܇d9VL[V֕xev}Z%y%yY;#'r W3Ir umFhϏB!ܘp9zAL3_?8[Udlj4D< s9d ķy ;тtEvq;^_`֥QފgPD/2v^j){t;A>~M}TPc %b<c8U?_hCYpn䞖VkǥlnTW"m}i'nMl |<@~ \T'8hyDY[ 7CbȲ4~{HMS]Q NMӗ^qMD(aCam,G^|w o9P x9W1<,ˤkypVbUpp{IYATNL(4f@ KxH+#W?Xj9afʌU2 thd*Kq O16}?U˙╺ܴι@A(qX+T#Nl[[4ofk".)bixl%y%wRg`*ٱ-/w's(`s&8\㌤~Ƙ]).84h&GpF@>5QG}Ҕ~L8I>xȇr.pn2y-ݱܔ׃r39>gXe^j{7/菼c< 8&23lO(n~Ƶrpv[cM"k&4\yzGcAx:$ի8߷&ϩ^iӻ\#z3{ \3j |0(:wwͩrhj)b>c$0ʹ:3al"l +=6mmm,dj|>Fˮ)G-q{n ؆'#hM2DOЯ/#.ϛZ"ߛCvFb;6ކ[aQZ,I Z~W~ }K c34`:T M`@(27醟Vyrj'k`XaW8QR&[o&B-WZ5L?_ oi},*~o ,F0꽝cȅG : .Q"vf&:xK&zwO)Q8P->2-*`WF6+|1޸9Kqcץc;_^ڦjȲGmxţm3*Y4׮-`{?x\kq62*߫{:G>b(_2)e,'h |O{z U@֜&v9R^̔DNS^v_"AAQŶrχܻz;`:(/vp?:vʃg}g5KϿop®,7|Awq΢˹:>޴tisG_ʚIKs7ɘF=Dtf8p< ~$wܻeأ(SƷ'7MOcT *Fq,$*0 >2, Z&~+1긆&w8Sf|'?ϒMD"IP|(M?~A֗ډ54)bN|>ugϣ nͩP}*MU(44bQa}~Pz{4P䰪@u̕[`m-84֦c{08丟9bBe85fHEε1\'Ir~'`Go[H}yݜDOULN Ͷ.Z4MBuMz kUEP_j/exAcɅ x ![eu`6ro-!I%bQ?̈́ʣ%YF݀ (6LYjFH )m/ccރN8QkT& F~Kx9O@_ϮՐ9 $! B@* ߇erAThkӆ.yN–)")*ӽ5_ j7NB!0'}{n)p,K]4ޯ{HǘZO=&r.:6ricmZ!Bm)ݫUqiryahZ|c!4b]New*F.W_Z9`=e n0mN@ÏJ4ҥ`6OlΝlrξsQ_vFԶ'{ &vbN] -iNO$G8pveZ 5`ժSm8y;ch"vʢz`]Roz.ᘉg~tlA=apEr5V|OKˑ U^00?>fS=S+؊.?r1qzscѢ(Ecv+[bk("a4rYK>[jŖ'68l$$"Ym=[K).<&—ڋ18Tnݬ@ſ1@^qlo Q]N_4<% :C܍σg X݂64 +[']˃VyS,HaZx^;vh>:.g|U]5.Wa+gtSfjSMLɶkdמ.:/#˯ppaC@"/WFAѬMGaZSժʛ*+!D3ڜJd9kEA0s!c3q+9A'sim/~Ҫ6A #I_WTP,k'lB}sR٠}-WTKr3K`K5G23wό-f}3FL9=F<9!H3uρvy FGSFP.munӾB9%:o5ME?{d4bg]DR+{?zgjkЕ ZnGY#=Can}n܅XR+y8xN}]`^'A::hܨny&[X/p^o֛Ab>xtI |cCzO q9u'LfyTMpՖ_/\R*&B!(JqKѝ׿[sj]nswF9@ q!lVDifozH'MƑ ͊|죨/wuyѓWMO7,N#Ð5k1qc;&ԬlJuZe% ЍnɄ+PnL,/ݤպEmD IsK˧JF6^\#4H/{Gv6E^w4ض$QI3IpzTENU^kHo=d#xr sHp t\/b6W~ -K~5]`8 y::ۑZ('LTƁݶÒ0vli\\]Ahe1gEvg'6vi7L~}A/I71^3~K1äęod ٲ%"?83Gc+`5Any|Ql6#N kOח}>ҽwۏ9cEfo4%Wif74#h/νKۋUӚYU OB؋gO& %4spR{ԼK'gED[?Ʋs9j ," }i:`ml*~}x;9^%ڵiy' 8bj6B }&$c;)t_&@z1"},sZʥ=Bd+Yq+HCt =4( #;Ebާt)lBڄK^A&@Z~W1; i䭨 iʚĽ߈ǃ.ϴ3dzYp2ivsbk޿G_I;X <w) &9`rv44xnF0L^8d M4xnS@waقS`u[}FhҦ SJ׺QبTJdmƯǝ] 6𹕣HvHZ> Zv0Nppkӝ^Xg7;^av8а徬H2*@)"j0w|m1, Ϳq r]qlHfTUTr# U v: owBr3BnF."|e;ZVׇ o 2S1kAF&c#hh_^uaX -Jα=FHHq|s)Nl'ıX DtPPSPT4T444vs-,fh3[Vi'gƩ&3pn>EKb ue,$Bt؝8,e8grqe;pkr㛧/g՗ѷ=Hu!eϖbi:[ XRQZ-0^;o pw7/}f(/V4+dѡH!:JZ,FA-d&pT!i@Ⱛ"8%0WTATgy :xǻYՕﯣB勅~q}[ԺEV X 0R#yYA^tX4ZKXKV]A+ޖכJ~Q~wL#C ΊU@^ (NZc2113D8٦DeC7AxY+Tet!<-~W[Ks^Hˋұr. ZBI4dT7flSHa9>LIo[5}C=i'veiWEC2:͆\ABul7,ƪ]XܬMQܘ"w7?<h,ó@9=/0KeqOW=QfB\78tudЦoN^ ]Ѽ 7Q @R Z"Է";cʿ+P Z( BN\3VTt&@~7o>~]'۝xYTs&Ӎ<7bM~-Z NȲîtÁ;+$TY\߳]].Yf%kyFgk-`eSbBG!u?^=_GPqFvh;YIMU( 3ƦYյF(6:yL_?߾얉yӒNJ)_cdëh6Pj ǫ3+*3:ewp|ՅP+\7ujJY'yODᲸ( Ķ"Y1 yixJ$= g*xnH+Q qxX}o[Of7-Ev[NEN;dꎒ8'[5{H  "KIPUXO~o(KX42Sd#J GdBZ%)G~%ɛzZj6VZBcW"mD! ZXSRp}ey䞞3ř>8V2~'cAY("+ O=tW] ƚZlha,MN~$Y~C˂3{3^Z[1+" +Ic]@M-Y[% > KLonkFŽs $ HUt$Z`PG@Jy)!v]$\%ͤ,*G b-38+d[ZH %uh.7*h($tq6|u:F LZ +Ԝ3BDV Q+$H Zf) )X6$)wv:8@-b34oA] Cp,7 vT)()s(/qu9B,GhaG\ܨjGҸ~o%P$[; |~niM"{brn4аB;>Օ1#4_"Հ$IkYSmenA÷?s'Uҭ+1׸C)r2BQ j0g )]{]~ǃ`d#zD|#Gt_$s Wʻ֌d܇Rz%lEIeɒ(VmMs=Oro:յ(B?I"ԲЖC_qᷪTX+$4nMe JϕҮQGjf(6X$:{vě-3{-pd+]d^fl0ΠTvlSmp®C\k!.%YN2G ˳ծ=K{G[wm^iK\{ KuWX-_'ScϓVԘɟ'M#!Ti(Ǫ"af+:)h%y4B%9Zpg>0ET=z(2K@ߡ˼+RXIgGEP- ez]n] 'hΑ*QLʱ.8@zʼM$CDߥBebHS.0/#rAVVbo󔊱- ,M 9i<-,N*_<(VH EE fZh,U%&݌K2(}TtmяJ=hYΠjųU7j(@f< VD* K256HiB]EY,|v"fA(ovPUΗ+tmR˕yŝ$]^.k"02ƨ']KO6_p iqmq,B+yEh$q;,UG,nE|0s]BSpUvp0&vst/;{^SƏNM?K Ԋ{P)=mq%<:y!aS"aI2^ͅ؝ꕨRBMͫ E%hB8- ֐SLВBg: K_;qBGҭf/Gzq0F;6=ǷOoG߿{.nܕN3wyto?:3 oSLX0( i@?͛ r$([6 D W?=-x!iWȹ; t>ӂƠ}9^xkhP21̒$o>\Nߍ5wO~Q1yF%w&;_}}_[ٯxO100644 actionlint.yaml!UiQF!>F40000 workflows9 Xi2Z6p9DPqd\xOO;J|Ow mDѡS.8 'x,Os+$100644 hero.svgL/g@?Ж|EB+$[-x&100644 docker.yml7T,ԽI(y)BneOcrtxGname: Docker on: workflow_dispatch: push: tags: ['v*'] permissions: contents: read packages: write id-token: write # amd64-only on luxfi's native ARC pool — the SPA build (Next.js + 8GB # heap) + Go cgo-sqlite Docker build under QEMU arm64 emulation pushes # build time from ~5 min to ~2 hours. Cluster runners are amd64; Mac # devs use OrbStack which has its own arm64 base image story. arm64 # rebuilds can come back via a separate matrix entry on a native # arm64 runner — not via QEMU. jobs: docker: # In-cluster ARC pool (lux-build autoscalingrunnerset in lux-k8s, org-scoped # to github.com/luxfi, amd64). The classic [self-hosted, linux, amd64] triple # is serviced by fleet arcd hosts that are not reliably available; lux-build # scales 0->N on demand and is the canonical luxfi image-build pool. runs-on: lux-build steps: - uses: actions/checkout@v4 - uses: docker/setup-buildx-action@v3 with: driver: docker-container driver-opts: network=host - uses: docker/login-action@v3 with: registry: ghcr.io username: ${{ github.repository_owner }} password: ${{ secrets.GITHUB_TOKEN }} - id: meta uses: docker/metadata-action@v5 with: images: ghcr.io/luxfi/explorer flavor: latest=auto tags: | type=semver,pattern={{version}} type=semver,pattern={{major}}.{{minor}} type=sha,prefix=sha- - uses: docker/build-push-action@v6 with: context: . platforms: linux/amd64 labels: ${{ steps.meta.outputs.labels }} tags: ${{ steps.meta.outputs.tags }} cache-from: type=gha,scope=explorer cache-to: type=gha,scope=explorer,mode=max provenance: false push: true KmLWTxp# The Dockerfile resolves private luxfi/* modules (graph, indexer, crypto, # ...) via go mod, and the GHCR push needs org-wide package write. The # default GITHUB_TOKEN is repo-scoped and cannot do either reliably, so # resolve a cross-org PAT (org GH_TOKEN, else repo UNIVERSE_PAT — both carry # write:packages) and use it for BOTH the ghcr login and the BuildKit # secret `ghtok`. Same mechanism as luxfi/node's docker.yml. - id: pat env: GH_TOKEN: ${{ secrets.GH_TOKEN }} UNIVERSE_PAT: ${{ secrets.UNIVERSE_PAT }} run: | tok="$GH_TOKEN"; src="GH_TOKEN" if [ -z "$tok" ]; then tok="$UNIVERSE_PAT"; src="UNIVERSE_PAT"; fi if [ -z "$tok" ]; then echo "::error::No GH_TOKEN or UNIVERSE_PAT secret set — go mod download / package push will fail on private luxfi/*"  exit 1 fi echo "Using secret: $src (length=${#tok})" echo "::add-mask::$tok" { echo= "token<> "$GITHUB_OUTPUT"teps.pat.outputs.tokenWlabels: | org.opencontainers.image.source=https://github.com/luxfi/explorerOn8secrets: | ghtok=${{ steps.pat.outputs.token4registry,ref=ghcr.io/luxfi/explorer:buildcache-amd644registry,ref=ghcr.io/luxfi/explorer:buildcache-amd64 ;ѭ7xkhP/rmC2ZS,zfݐBxkhP/3x}hAhUgcW}8 ͵x # Lux Explorer data-layer image (v1.3.0+). # # As of v1.3.0 the Go binary is API-only — it serves /v1/* (indexer + # blockscout-compat REST), /health, /envs.js, and per-host brand SVGs. # Every other path returns 404 and the IngressRoute routes it to the # per-brand Blockscout FE Deployment (ghcr.io/{brand-org}/explore-{env}). # Built from luxfi/explore via Dockerfile.branded — see ~/work/lux/explore. ARG GO_VERSION=1.26 # ---- Stage 1: build the unified FE + indexer + graph binary ---- # graph + indexer are consumed as Go modules pinned in go.mod (luxfi/graph # v1.2.3, luxfi/indexer v1.4.5), NOT cloned as siblings — explorer has no # replace directive, so under -mod=mod the module cache is authoritative. FROM golang:${GO_VERSION}-alpine AS builder ARG VERSION=dev RUN apk add --no-cache gcc musl-dev sqlite-dev git # luxfi/* modules are private and may be re-tagged; resolve them direct # (not via proxy/sumdb) and skip checksum-db cross-checks, exactly as the # node image does. The default GITHUB_TOKEN is repo-scoped; a cross-org PAT # is injected as the BuildKit secret `ghtok` by docker.yml. ENV GOPRIVATE=github.com/luxfi/*,github.com/hanzoai/* ENV GONOSUMCHECK=github.com/luxfi/* ENV GONOSUMDB=github.com/luxfi/* ENV GONOPROXY=github.com/luxfi/* ENV GOFLAGS=-mod=mod WORKDIR /src COPY go.mod go.sum ./ # Configure git auth once so both `go mod download` here and the implicit # fetch during `go build` can reach private luxfi/* modules. RUN --mount=type=secret,id=ghtok,required=false \ if [ -s /run/secrets/ghtok ]; then \ git config --global url."https://x-access-token:$(cat /run/secrets/ghtok)@github.com/".insteadOf "https://github.com/"; \ fi && \ go mod download COPY . . RUN CGO_ENABLED=1 CGO_CFLAGS="-D_LARGEFILE64_SOURCE" \ go build -trimpath \ -ldflags="-s -w -X main.version=${VERSION}" \ -o /out/explorer . # ---- Stage 2: runtime ---- FROM alpine:3.21 RUN apk add --no-cache ca-certificates sqlite-libs wget COPY --from=builder /out/explorer /usr/local/bin/explorer RUN adduser -D -u 65532 explorer USER explorer VOLUME /data ENV DATA_DIR=/data HTTP_ADDR=:8090 EXPOSE 8090 HEALTHCHECK --interval=30s --timeout=5s --start-period=10s \ CMD wget -qO- http://localhost:8090/health || exit 1 ENTRYPOINT ["explorer"] !\/xC6JFW gJ100644 go.sumHa< ϞA=9xO7-Rxkh(!4oΫ!HxPC[)9CuIq!100644 chains.example.yaml O"RUFpKh TOxK

explorer

# Explorer Single-binary Lux explorer: chain indexer, GraphQL engine, and SPA frontend in one Go process. Imports [`luxfi/indexer`](https://github.com/luxfi/indexer) and [`luxfi/graph`](https://github.com/luxfi/graph) as libraries; embeds the [`luxfi/explore`](https://github.com/luxfi/explore) Next.js build via `go:embed`. ``` ghcr.io/luxfi/explorer -> indexes one or more EVM chains (luxfi/indexer) -> exposes per-chain GraphQL (luxfi/graph) -> serves embedded SPA + REST API (luxfi/explore) ``` ## Routes | Path | Purpose | |---------------------------------------------------|----------------------------------| | `/` | SPA (embedded; SPA-routing fallback) | | `/envs.js` | Runtime config `window.ENV = {...}` | | `/icon.svg`, `/logo.svg` | Per-host brand assets (disk override) | | `/health` | Service health | | `/v1/indexer/*` | Default chain explorer API | | `/v1/indexer/{slug}/*` | Per-chain explorer API | | `/v1/explorer/{slug}/*` | Legacy alias for `/v1/indexer/{slug}` | | `/v1/graph/{slug}/{subgraph}/graphql` | Per-chain, per-subgraph GraphQL | | `/v1/explorer/admin/chains[/{slug}]` | Runtime registry CRUD | | `/v1/explorer/realtime` | WebSocket realtime hub | | `/v1/explorer/realtime/stats` | Realtime stats | ## Quick Start ```bash docker run -p 8090:8090 \ -v $(pwd)/chains.example.yaml:/etc/explorer/chains.yaml:ro \ -v explorer-data:/data \ ghcr.io/luxfi/explorer:latest \ --config /etc/explorer/chains.yaml ``` Or with compose: ```bash docker compose up ``` ## Configuration `chains.yaml` is the single source of truth. Every aspect of the deploy -- chains, branding, GraphQL subgraphs, network switcher links -- is per-chain customizable. See [`chains.example.yaml`](chains.example.yaml) for the full schema. ```yaml data_dir: /data http_addr: :8090 brand_default: name: Lux Explorer coin: LUX accent_color: "#5cf" networks: - { label: Mainnet, domain: explorer.lux.network, chain_id: 96369 } chains: - slug: cchain name: Lux C-Chain chain_id: 96369 type: evm rpc: https://api.lux.network/mainnet/ext/bc/C/rpc coin: LUX enabled: true default: true indexer: poll_interval: 30s graph: enabled: true subgraphs: - { name: amm, schema: amm, enabled: true } brand: name: Lux C-Chain accent_color: "#5cf" ``` `$ENV_VAR` substitution in `rpc:` / `ws:` lets one file template every network -- mount it read-only and inject secrets via env vars. ## Per-Network Customization The same image powers every deploy. To rebrand for a different network: 1. Mount a different `chains.yaml`. 2. Optionally mount `icon.svg` / `logo.svg` at the path referenced by `chains.yaml` -- they are read from disk per-request, not embedded. 3. Set environment variables to fill the `${VAR}` placeholders. No image rebuild needed. The SPA reads chain list and brand at runtime from `/envs.js`. ## Runtime Registry Chains can be added, updated, and removed at runtime without restart: ```bash # Add curl -X POST http://localhost:8090/v1/explorer/admin/chains \ -H 'Content-Type: application/json' \ -d '{"slug":"new","name":"New","chain_id":123,"rpc":"http://node:8545","type":"evm"}' # List curl http://localhost:8090/v1/explorer/admin/chains # Remove curl -X DELETE http://localhost:8090/v1/explorer/admin/chains/new ``` Adding a chain spawns its indexer + (optional) graph workers; removing cancels them and frees the routes. ## mDNS Discovery Set `EXPLORER_MDNS=true` to auto-register chains advertised by local Lux nodes (`_luxd._tcp`, `_zood._tcp`, `_hanzod._tcp`, `_parsd._tcp`). The explorer queries `info.getChains` on the discovered node and registers each tracked chain. mDNS-sourced chains never override config-sourced entries. ## Storage Layout ``` /data/ cchain/ query/indexer.db (SQLite WAL, indexer) {zapdb}/ (KV store) graph/ amm/graph.db (SQLite WAL, per-subgraph) zoo/ ... ``` Each chain (and each subgraph) owns an isolated SQLite + KV store. WAL is optionally streamed to S3 with PQ encryption when `REPLICATE_S3_ENDPOINT` is set -- see `luxfi/indexer/daemon`. ## Local Build ```bash # Sibling layout: ~/work/lux/{indexer,graph,explorer} cd ~/work/lux/explorer go build -o explorer . ``` `go.mod` uses local `replace` directives pointing at `../indexer` and `../graph`. Production CI clones all three repos into the same layout inside the Docker build. ## Endpoints (curl examples) ```bash curl http://localhost:8090/health curl http://localhost:8090/v1/indexer/cchain/blocks/latest curl -X POST http://localhost:8090/v1/graph/cchain/amm/graphql \ -H 'Content-Type: application/json' \ -d '{"query":"{ swaps(first:5) { id amount0 amount1 } }"}' ``` ## Related - [`luxfi/indexer`](https://github.com/luxfi/indexer) -- chain indexer library - [`luxfi/graph`](https://github.com/luxfi/graph) -- per-chain GraphQL library - [`luxfi/explore`](https://github.com/luxfi/explore) -- Next.js SPA ښ xkh(BTІ fݍ.mwprc|}w,Hjѽ>BZQ~^Ij^J|Ijq^z>WoH\'C1kejrSq}5/@#؉agC v\wR',.q';Gfs="{6z~ o[ PxXn8}W v{d>nvS4&[tPms#*)9N~addQr8ؠ:X#rp ҡs%!uHoa!$T4c^rq~&Sk2Ø H 076Γ *8Yw [VPCBfM~^: T? M%01|T}R\f|eWt8tykF. qBv_:eg :g9Ez0ڔ 1O@CƤrw~|zbLkE¼a5XoUAeҫ"=B$~~ǣO~RIv\$̱Xzwqޭ1aE,R\TdT/"`RL4F8$cq}͂cR}28zO_8>>[sQM>ฮ8{2gqQp|XGQ{Qm.5 ISV ;[`^5׻V+B0Hws4,NK[`/у ړR`O(SXy7=̩*j+,cNŴX󹌸2O4QJ9ɼ1h}5.D*x(22 v1/bc/B! v1/bc/T!0 ($ )xH$# Lux Explorer data-layer image (v1.3.0+). # # As of v1.3.0 the Go binary is API-only — it serves /v1/* (indexer + # blockscout-compat REST), /health, /envs.js, and per-host brand SVGs. # Every other path returns 404 and the IngressRoute routes it to the # per-brand Blockscout FE Deployment (ghcr.io/{brand-org}/explore-{env}). # Built from luxfi/explore via Dockerfile.branded — see ~/work/lux/exploreU; 2omGxFpackage main import ( "bytes" "embed" "encoding/json" "fmt" "io/fs" "net/http" "os" "path/filepath" "strings" "sync"V ) // staticFS embeds named brand assets only — icon.svg and logo.svg // fallbacks..no longer serves the Blockscout // SPA; each brand's FE runs as its own per-(brand, env) Deployment // (ghcr.io/{org}/explore-{ env}:vX.Y.Z)cthe // catch-all to that FE Service. The Go binary keeps /v1/* (indexer + // blockscout-compat APIs)the per-host brand // SVG endpoints — e. // //go:embed all:static var staticFS embed.FS // Frontend serves runtime config (/envs.js) and per-host brand assets // (/icon.svg, /logo.svg). Brand assets read from disk on every request so a // deploy can swap them without rebuilding the binary. // // Static directory override: if cfg.StaticDir (or $EXPLORER_STATIC_DIR) // points at an existing directory, brand-asset lookups prefer the on-disk // copy over the embedded FS. This lets a ConfigMap-mounted SVG bundle // override the in-binary defaults without rebuilding. // // SPA serving was removed in v1.3.0 — the catch-all `/` route is gone and // any path not explicitl*y registered returns 404. The per-brand // = owns the // SPA surface. type Frontend struct { cfg Config registry *ChainRegistry root fs.FS // embedded brand-asset FS (always present) overlay fs.FS // disk overlay (nil if cfg.StaticDir not set) } // NewFrontend returns a frontend handler bound to a config and chain registry. func NewFrontend(cfg Config, r *ChainRegistry) (*Frontend, error) { root, err := fs.Sub(staticFS, "static") if err != nil { return nil, err } f := &Frontend{cfg: cfg, registry: r, root: root} dir := cfg.StaticDir if dir == "" { dir = os.Getenv("EXPLORER_STATIC_DIR") } if dir != "" { if st, err := os.Stat(dir); err == nil && st.IsDir() { f.overlay = os.DirFS(dir) } } return f, nil } // readStatic returns the bytes for `name` from the overlay if present, // otherwise from the embedded FS. Returns nil if neither has the file. func (f *Frontend) readStatic(name string) []byte { if f.overlay != nil { if data, err := fs.ReadFile(f.overlay, name); err == nil { return data } } if data, err := fs.ReadFile(f.root, name); err == nil { return data } return nil } // Mount installs the data-layer endpoints — /envs.js, /icon.svg, // /logo.svg, plus any extra brand SVGs present in the overlay (e.g. // /icon-zoo.svg, /logo-lux.svg). No jcatch-all SPA route: any other path // returns 404 so the IngressRoute layer routes it to the per-brand // . func (f *Frontend) Mount(mux *http.ServeMux) { mux.HandleFunc("GET /envs.js", f.handleEnvs) mux.HandleFunc("GET /icon.svg", f.handleIcon) mux.HandleFunc("GET /logo.svg", f.handleLogo) for _, name := range f.brandAssetNames() { mux.HandleFunc("GET /"+name, f.handleNamedBrandAsset(name)) } } // brandAssetNames lists every per-brand SVG/PNG file the overlay (or the // embedded FS) carries. Used to register one explicit handler per file at // startup so the rest of the path-space cleanly 404s. func (f *Frontend) brandAssetNames() []string { seen := map[string]struct{}{} var out []string collect := func(dir fs.FS) { if dir == nil { return } entries, err := fs.ReadDir(dir, ".") if err != nil { return } for _, e := range entries { n := e.Name() if e.IsDir() || n == "icon.svg" || n == "logo.svg" { continue } switch strings.ToLower(filepath.Ext(n)) { case ".svg", ".png", ".jpg", ".jpeg", ".webp", ".ico": default: continue } if _, ok := seen[n]; ok { continue } seen[n] = struct{}{} out = append(out, n) } } collect(f.overlay) collect(f.root) return out } // handleNamedBrandAsset returns a handler that serves a specific named // file from the overlay (preferred) or the embedded FS. 404 if neither // has it. func (f *Frontend) handleNamedBrandAsset(name string) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { if data := f.readStatic(name); data != nil { w.Header().Set("Content-Type", contentTypeFor(name)) w.Header().Set("Cache-Control", "public, max-age=300") w.Write(data) return } http.NotFound(w, r) } } // handleEnvs returns runtime config the SPA reads instead of build-time env // vars. This is what makes per-network customization possible without a // rebuild: deploy the same image, mount a different chains.yaml, get a // different brand + chain list. func (f *Frontend) handleEnvs(w http.ResponseWriter, r *http.Request) { hostBrand := f.brandForHost(r.Host) hostSlug := f.chainSlugForHost(r.Host) chains := f.chainListJSON() // When the host pins a specific chain (e.g. explore.zoo.network → // zoo, explorer.zoo-test.network → zoo), promote that chain to // default and demote any other config-level default. The SPA's chain // switcher honours the "default" flag. if hostSlug != "" { for i := range chains { if chains[i]["slug"] == hostSlug {  chains[i]["default"] = true } else { chains[i]["default"] = false } } } current, peers := f.networksForHost(r.Host) env := map[string]any{ "VITE_CHAINS": chains, "VITE_NETWORKS": f.cfg.Networks, "VITE_BRAND":  hostBrand, "VITE_CURRENT_NETWORK": current, "VITE_NETWORK_HOSTS": peers, } body, _ := json.Marshal(env) var buf bytes.Buffer buf.WriteString("window.ENV = ") buf.Write(body) buf.WriteString(";\n") w.Header().Set("Content-Type", "application/javascript") w.Header().Set("Cache-Control", "no-cache") w.Write(buf.Bytes()) } // handleIcon serves the per-host or default icon.svg from disk. func (f *Frontend) handleIcon(w http.ResponseWriter, r *http.Request) { f.serveBrandFile(w, r, func(b Brand) string { return b.IconFile }, "icon.svg") } // handleLogo serves the per-host or default logo.svg from disk. func (f *Frontend) handleLogo(w http.ResponseWriter, r *http.Request) { f.serveBrandFile(w, r, func(b Brand) string { return b.LogoFile }, "logo.svg") } // serveBrandFile resolves the file path from the matched brand (per-chain or // default) and sends it. Falls back to the on-disk overlay (if configured) // then the embedded SPA's named asset. func (f *Frontend) serveBrandFile(w http.ResponseWriter, r *http.Request, pick func(Brand) string, fallback string) { brand := f.brandStruct(r.Host) if path := pick(brand); path != "" { if data, err := os.ReadFile(path); err == nil { w.Header().Set("Content-Type", contentTypeFor(path)) w.Header().Set("Cache-Control", "public, max-age=300") w.Write(data) return } } if data := f.readStatic(fallback); data != nil { w.Header().Set("Content-Type", contentTypeFor(fallback)) w.Header().Set("Cache-Control", "public, max-age=300") w.Write(data) return } http.NotFound(w, r) } // brandForHost returns a JSON-shaped brand for /envs.js. It strips file paths. func (f *Frontend) brandForHost(host string) map[string]any { b := f.brandStruct(host) return map[string]any{ "name": b.Name, "coin": b.Coin, "accentColor": b.AccentColor, "iconUrl": b.IconURL, "logoUrl": b.LogoURL, } } // brandStruct returns the Brand for a request host: a chain whose name or // slug matches the hostname wins; otherwise the global default. // // See hostMatchesSlug for the list of supported hostname shapes. func (f *Frontend) brandStruct(host string) Brand { if c, ok := f.matchChain(host); ok && c.Brand != nil { return *c.Brand } return f.cfg.BrandDefault } // chainSlugForHost returns the slug of the chain pinned by the request host, // or "" if the host does not name a chain. Used by handleEnvs to promote a // per-host chain to the SPA's default selection. func (f *Frontend) chainSlugForHost(host string) string { if c, ok := f.matchChain(host); ok { return c.Slug } return "" } // matchChain finds the first configured chain whose slug appears in the // request host. Matches these hostname shapes, in order of specificity: // - "{slug}"  — bare slug (curl localhost) // - "{slug}.tld..." — {slug}.lux.network, {slug}.hanzo.ai // - "explore-{slug}.tld..." — explore-hanzo.lux.network // - "explorer-{slug}.tld..." — explorer-hanzo.lux.network // - "api-explore-{slug}.tld..." — api-explore-hanzo.lux.network // - "explore.{slug}.tld..." — explore.hanzo.ai, explore.zoo.ngo // - "explorer.{slug}.tld..." — explorer.hanzo.ai, explorer.zoo.network // - "api-explore.{slug}.tld..." — api-explore.hanzo.ai // - "explore-{slug}-{env}.tld..."  — explore-hanzo-test.lux.network // - "explorer-{slug}-{env}.tld..." — explorer-hanzo-test.lux.network // - "api-explore-{slug}-{env}.tld..." — api-explore-hanzo-dev.lux.network // - "explore.{slug}-{env}.tld..." — explore.zoo-test.network // - "explorer.{slug}-{env}.tld..." — explorer.zoo-test.network // - "api-explore.{slug}-{env}.tld..." — api-explore.zoo-test.network // // First chain match wins on ambiguous hosts. func (f *Frontend) matchChain(host string) (ChainConfig, bool) { host = strings.ToLower(strings.SplitN(host, ":", 2)[0]) for _, c := range f.cfg.Chains { if hostMatchesSlug(host, c.Slug) { return c, true } } return ChainConfig{}, false } // hostMatchesSlug is the pure string predicate for chain↔host matching. // Kept separate from matchChain so unit tests can cover it directly. func hostMatchesSlug(host, slug string) bool { if slug == "" { return false } if host == slug { return true } // Direct slug-as-subdomain: zoo.lux.network, hanzo.ai. if strings.HasPrefix(host, slug+".") || strings.HasPrefix(host, slug+"-") { return true } // Brand-owned domains: explore.zoo.network, explorer.zoo-test.network, // api-explore.zoo.ngo, etc. Each "explore"/"explorer" prefix combines // with "." or "-" as the slug separator. prefixes := []string{ "explore-", "explorer-", "api-explore-", "api-explorer-", "explore.", "explorer.", "api-explore.", "api-explorer.", } for _, p := range prefixes { // {prefix}{slug}.tld — e.g. explore.zoo.network, explore-zoo.lux.network if strings.HasPrefix(host, p+slug+".") { return true }  // {prefix}{slug}-{env}.tld — e.g. explore-zoo-test.lux.network, // explorer.zoo-test.network if strings.HasPrefix(host, p+slug+"-") { return true } } return false } // networksForHost returns (current network label, sibling host map). The // SPA renders a "Network: mainnet ▾" dropdown — when the user picks // another label, the SPA redirects to the corresponding host. Hosts are // derived purely from the request host: explore.zoo.network (mainnet) // has sibling explorer.zoo-test.network (testnet); explore.lux.network // has sibling explorer.lux-test.network; and the reverse. // // Host shape rules: // - mainnet: prefix is "explore.", brand domain is "." // (e.g. zoo.network, lux.network, hanzo.ai). Sibling is //  "explorer.-test.network". // - testnet: prefix is "explorer.", brand domain is "-test.network". // Sibling is "explore..network" (or .ai / .ngo per brand // when known; we default to .network because all the actual //  deployed testnet hosts are *.network). // - lux.network (no brand prefix, generic explore.lux.network) is // special-cased: mainnet=explore.lux.network, testnet=explorer.lux-test.network. // // If we can't classify the host (admin tooling on localhost, internal // service-mesh hostnames), we return ("", nil) and the SPA omits the // dropdown. func (f *Frontend) networksForHost(host string) (string, map[string]string) { host = strings.ToLower(strings.SplitN(host, ":", 2)[0]) // Find the brand stem and current env from the host. The two // shapes we support are "{prefix}.{brand}.{tld}" (mainnet) and // "{prefix}.{brand}-{env}.{tld}" (non-mainnet). brand, env, dotted, ok := parseBrandEnv(host) if !ok { return "", nil } // All deployed testnet/devnet hosts are *.network. Mainnet // brand hosts vary: zoo.network, lux.network, hanzo.ai, hanzo.network, // zoo.ngo, etc. For the round-trip from testnet back to mainnet // we need to know which mainnet TLD the brand uses. When the user // is already on a brand-owned domain (explore.{brand}.{tld}), // preserve that TLD so the mainnet option is idempotent. When the // user is on the lux.network-prefix shape (explore-{brand}.lux.network) // or any non-brand-owned shape, default to ".network" — every brand // we ship has an X.network mainnet alias. mainnetTLD := ".network" if env == "" && dotted { if dot := strings.Index(host, brand+"."); dot >= 0 { mainnetTLD = host[dot+len(brand):] } } mainnetHost := "explore." + brand + mainnetTLD testnetHost := "explorer." + brand + "-test.network" peers := map[string]string{ "mainnet": mainnetHost, "testnet": testnetHost, } switch env { case "": return "mainnet", peers case "test", "testnet": return "testnet", peers case "dev", "devnet": // Optional devnet entry; only surfaces when present. peers["devnet"] = "explorer." + brand + "-dev.network" return "devnet", peers default: return env, peers } } // parseBrandEnv extracts the brand stem and env tag from a host. Recognizes: // // explore.{brand}.{tld} → ({brand}, "", dotted=true) // explorer.{brand}.{tld}  → ({brand}, "", dotted=true) // explore.{brand}-{env}.{tld} → ({brand}, {env}, dotted=true) // explorer.{brand}-{env}.{tld} → ({brand}, {env}, dotted=true) // explore-{brand}.lux.network → ({brand}, "", dotted=false) // explore-{brand}-{env}.lux.network → ({brand}, {env}, dotted=false) // // Returns ok=false on hosts we can't classify (localhost, IPs, internal // service-mesh names like *.svc.cluster.local). // // `dotted` distinguishes brand-owned hosts (explore.zoo.network — TLD // belongs to the brand) from lux-prefix hosts (explore-zoo.lux.network — // brand is just a subdomain on lux.network) so the network switcher can // pick the right mainnet TLD for the sibling URL. func parseBrandEnv(host string) (brand, env string, dotted, ok bool) { if host == "" || strings.HasSuffix(host, ".svc.cluster.local") || strings.HasSuffix(host, ".local") { return "", "", false, false } stripPrefix := func(s, p string) (string, bool) { if strings.HasPrefix(s, p) { return s[len(p):], true } return s, false } // "explore.{brand}{maybe-env}.{tld}" / "explorer.{brand}{maybe-env}.{tld}" for _, p := range []string{"explore.", "explorer.", "api-explore.", "api-explorer."} { rest, matched := stripPrefix(host, p) if !matched { continue } dot := strings.Index(rest, ".") if dot < 1 { return "", "", false, false } stem := rest[:dot] brand, env = splitBrandEnv(stem) if !isValidBrand(brand) { return "", "", false, false  } return brand, env, true, true } // "explore-{brand}{maybe-env}.lux.network" / "explorer-{brand}{maybe-env}.lux.network" for _, p := range []string{"explore-", "explorer-", "api-explore-", "api-explorer-"} { rest, matched := stripPrefix(host, p) if !matched { continue } dot := strings.Index(rest, ".") if dot < 1 { return "", "", false, false } stem := rest[:dot] brand, env = splitBrandEnv(stem) if !isValidBrand(brand) { return "", "", false, false } return brand, env, false, true } return "", "", false, false } // isValidBrand restricts brand stems to alphabetic (or digit-containing) tokens // at least 2 chars long. Rejects numeric-only stems (IP addresses), empty, // and stems beginning with a digit (so "10" from "10.0.0.1" never matches). func isValidBrand(s string) bool { if len(s) < 2 { return false } if s[0] < 'a' || s[0] > 'z' { return false } for i := 0; i < len(s); i++ { c := s[i] if !(c >= 'a' && c <= 'z') && !(c >= '0' && c <= '9') {  return false } } return true } // splitBrandEnv splits "zoo-test" into ("zoo", "test"); "zoo" stays as ("zoo", ""). // Only recognises known env suffixes (test, testnet, dev, devnet, local) so // hyphenated brand names ("api-zoo-exchange") still parse as one stem. func splitBrandEnv(stem string) (brand, env string) { for _, e := range []string{"-test", "-testnet", "-dev", "-devnet", "-local"} { if strings.HasSuffix(stem, e) { return strings.TrimSuffix(stem, e), strings.TrimPrefix(e, "-") } } return stem, "" } // chainListJSON returns a SPA-friendly chain list from the live registry, // not the static config — chains added via mDNS/admin show up immediately. var chainListMu sync.Mutex func (f *Frontend) chainListJSON() []map[string]any { chainListMu.Lock() defer chainListMu.Unlock() out := []map[string]any{} if f.registry == nil { return out } for _, c := range f.registry.List() { out = append(out, map[string]any{ "slug": c.Slug, "name": c.Name, "chainId": c.ChainID, "rpc": c.RPC, "coin": c.CoinSymbol, "type": c.Type, "default": c.Default, }) } return out } // contentTypeFor maps a file extension to a Content-Type, defaulting to // application/octet-stream. func contentTypeFor(path string) string { switch strings.ToLower(filepath.Ext(path)) { case ".svg": return "image/svg+xml" case ".png": return "image/png" case ".jpg", ".jpeg": return "image/jpeg" case ".webp": return "image/webp" case ".ico": return "image/x-icon" default: return "application/octet-stream" } } // fingerprint returns a short, stable identifier for the embedded asset // bundle, useful for cache-busting log lines at startup. func fingerprint() string { root, err := fs.Sub(staticFS, "static") if err != nil { return "0" } count := 0 _ = fs.WalkDir(root, ".", func(_ string, _ fs.DirEntry, _ error) error { cou@nt++ return nil }) return fmt.Sprintf("assets=%d", count) } ~Arxg#Knet/http" "net/http/httptestT&testing" ) // TestFrontendNoSPA verifies the v1.3.0 contract — the Go binary does // NOT serve a SPA. Any non-data-layer patBh returns 404 so the // IngressRoute hands it off to the per-brand. // Compare to the pre-v1.3.0 behaviour where `/` returned an embedded // index.html. func TestFrontendNoSPA(t *testing.T) { _cfg := Config{BrandDefault: Brand{Name: "Test"}} f, err := NewFrontend(cfg, NewChainRegistry():t.Fatal(err) } mux := http.NewServeMux() f.Mount(mux) 9/", "/block/1", "/_next/static/chunks/foo.js", "/some/random/path"} { req := httptest.NewRequest("GET", p, nil) rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) if rec.Code != 404 { t.Errorf("path %q: got HTTP %d, want 404 (FE Deployment owns this surface now)", p, rec.Code) } } } // TestFrontendBrandAssetsServed verifies the data-layer endpoints still // work  /logo.svg, and any extra named asset (e.g. // /icon-zoo.svg) the overlay carries. These are what the FE depends on // from the Go binary. func TestFrontendBrandAssetsServed(t *testing.T) { dir := t.TempDir() if err := os.WriteFile(filepath.Join(dir, "icon.svg"), []byte(""), 0644); err != nil { t.Fatal(err) } if err := os.WriteFile(filepath.Join(dir, "logo.svg"), []byte(""), 0644); err != nil { t.Fatal(err) } if err := os.WriteFile(filepath.Join(dir, "icon-zoo.svg"), []byte(""), 0644); err != nil { t.Fatal(err) } cfg := Config{StaticDir: dir, BrandDefault: Brand{Name: "Test"}} f,+ err := NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } mux := http.NewServeMux() f.Mount(mux) for _, tc := range []struct { path string want string }{ {"/icon.svg", ""}, {"/logo.svg", ""}, {"/icon-zoo.svg", ""}, } { req := httptest.NewRequest("GET", tc.path, nil) rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) if rec.Code != 200 { t.Errorf("path %q: got HTTP %d, want 200", tc.path, rec.Code) } if got := rec.Body.String(); got != tc.want { t.Errorf("path %q: got body %q, want %q", tc.path, got, tc.want) } } } // TestFrontendOverlayFromEnv verifies $EXPLORER_STATIC_DIR is the env // equivalent of cfg.StaticDir. The brand asset must be served from the // overlay even with an empty cfg. func TestFrontendOverlayFromEnv(t *testing.T) { dir := t.TempDir() if err := os.WriteFile(filepath.Join(dir, "icon.svg"), []byte(""), 0644); er!r != nil { t.Fatal(err) } t.S^h, dir) cfg := Config{BrandDefault: Brand{Name: "Test"}} f, err := NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } if f.overlay == nil { t.Fatal("expected overlay populated from $EXPLORER_STATIC_DIR") } mux := http.NewServeMux() f.Mount(mux) req := httptest.NewRequest("GET", "/icon.svg", nil) rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) if !strings.Contains(rec.Body.String(), "id=env") { t.Fatalf("expected env-overlay icon, got %q", rec.Body.String()) } } // TestBrandStructHostMatching covers every hostname shape the unified // explorer's IngressRoutes hand it: the per-chain brand must win over // BrandDefault for both UI hosts (explore-{slug}, explore.{slug}.tld) // and API hosts (api-explore-{slug}). The matcher must NOT bleed across // chains — a hanzo host must not pick zoo's brand or vice versa. func TestBrandStructHostMatching(t *testing.T) { hanzoBrand := Brand{Name: "Hanzo", Coin: "AI", AccentColor: "#0b1220"} zooBrand := Brand{Name: "Zoo", Coin: "ZOO", AccentColor: "#7c3aed"} cfg := Config{ BrandDefault: Brand{Name: "Lux Explorer"}, Chains: []ChainConfig{  {Slug: "cchain", Brand: &Brand{Name: "Lux C-Chain", Coin: "LUX"}}, {Slug: "hanzo", Brand: &hanzoBrand}, {Slug: "zoo", BHrand: &zooBrand}, }, } f, err := NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } cases := []struct { host string want string }{ // Bare slug + slug-prefix shape. {"hanzo", "Hanzo"},` {"hanzo.lux.network", "Hanzo"}, // explore-{slug} prefix shape (lux.network UI hosts). {" ", "Hanzo"}, {""?", "Hanzo"}, {"explore-hanzo-dev.lux.network", "Hanzo"}, {"(Q", "Zoo"}, // api-explore-{slug} prefix shape (lux.network API hosts). {"api- ", "Hanzo"}, {"api-"", "Hanzo"}, {"api-(", "Zoo"}, // explore.{slug}.tld shape (brand-owned domains). {"explore.hanzo.ai", "Hanzo"}, {"explore.hanzo.network", "Hanzo"}, {"explore.zoo.network", "Zoo"}, {"explore.zoo.ngo", "Zoo"}, {"api-explore.hanzo.ai", "Hanzo"}, {"api-explore.zoo.ngo", "Zoo"}, // explorer.{slug}.tld shape (alias of explore.* for brand-owned domains). {"explorer.zoo.network", "Zoo"},f {"explorer.hanzo.ai", "Hanzo"}, // {slug}-{env}.tld shape — brand-owned testnet/devnet domains.;)% is the primary case this fixes. {"A)", "Zoo"}, {"#?", "Zoo"}, {"explorer.hanzo-test.network", "Hanzo"}, {"api-#", "Zoo"}, // Mismatched hosts fall back to BrandDefault. {"explore.lux.network", "Lux Explorer"}, {"unknown.example.com", "Lux Explorer"}, // Cross-contamination guard: explore-spcfoo must NOT match spc. {"explore-spcfoo.lux.network", "Lux Explorer"}, // Cross-contamination guard: zoofoo must NOT match zoo. {"explore.zoofoo.network", "Lux Explorer"}, {"explorer.zoofoo.network", "Lux Explorer"}, } for _, tc := range cases { t.Run(tc.host, func(t *testing.T) { got := f.brandStruct(tc.host).Name if got != tc.want { t.Fatalf("host=%q: got brand=%q, want %q", tc.host, got, tc.want) } }) } } // TestNetworksForHost covers the network dropdown payload the SPA reads // from /envs.js. Mainnet hosts return ("mainnet", siblings) and testnet // hosts return ("testnet", siblings); unparseable hosts return ("", nil). func TestNetworksForHost(t *testing.T) { cfg := Config{ BrandDefault: Brand{Name: "Lux Explorer"}, Chains: []ChainConfig{ {Slug: "cchain"}, {Slug: "zoo"}, G{Slug: "hanzo"}, }, } f, err := NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } cases := []struct { host string wantCurrent string wantMainnet string wantTestnet string }{ [// Zoo (brand-owned domains). {"explore.zoo.network", "mainnet", "explore.zoo.network", "A)"}, {"A)&", "testnet", "explore.zoo.network", "A)"}, // Lux (brand-owned domains). {"explore.lux.network", "mainnet", "explore.lux.network", "explorer.lux-test.network"},  {"explorer.lux-test.network", "testnet", "explore.lux.network", "explorer.lux-test.network"}, // Hanzo brand on .ai mainnet, .network testnet. {"explore.hanzo.ai", "mainnet", "explore.hanzo.ai", "explorer.hanzo-test.network"}, {"explorer.hanzo-test.network", "testnet", "explore.hanzo.network", "explorer.hanzo-test.network"}, // lux.network prefix shape — explore-{slug}.lux.network. {"(&", "mainnet", "explore.zoo.network", "A)"}, {")&", "testnet", "explore.zoo.network", "A)"}, } for _, tc := range cases { t.Run(tc.host, func(t *testing.T) { cur, peers := f.networksForHost(tc.host) if cur != tc.wantCurrent { t.Errorf("current: got %q want %q", cur, tc.wantCurrent) } if peers["mainnet"] != tc.wantMainnet { t.Errorf("mainnet: got %q want %q", peers["mainnet"], tc.wantMainnet) } if peers["testnet"] != tc.wantTestnet {  t.Errorf("testnet: got %q want %q", peers["testnet"], tc.wantTestnet) } }) } // Unparseable hosts return empty. for _, h := range []string{"localhost", "10.0.0.1", "explorer.lux-mainnet.svc.cluster.local", ""} { cur, peers := f.networksForHost(h) if cur != "" || peers != nil { t.Errorf("expected empty result for %q, got cur=%q peers=%v", h, cur, peers) } } }  // TestChainSlugForHost covers the host→default-chain promotion that // handleEnvs uses to set the SPA's initial chain selec!tion. Hosts that // pin a chain ((/') must // return the slug; generic hosts (explore.lux.network) must return "". func TestChainSlugForHost(t *testing.T) { zooBrand := Brand{Name: "Zoo"} hanzoBrand := Brand{Name: "Hanzo"} cfg := Config{ BrandDefault: Brand{Name: "Lux Explorer"}, Chains: []ChainConfig{ {Slug: "cchain", Brand: &Brand{Name: "Lux C-Chain"}}, {Slug: "hanzo", Brand: &hanzoBrand}, {Slug:Q "zoo", Brand: &zooBrand}, }, } f, err := NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } cases := []struct { host string want string }{ {"explore.zoo.network", "zoo"}, {"explore.zoo.ngo", "z-oo"}, {"explorer.zoo.network", "zoo"}, {"A)", "zoo"}, {"#", "zoo"}, {"(", "zoo"}, {")", "zoo"}, {"explore.hanzo.ai", "hanzo"}, {"explorer.hanzo-test.network", "hanzo"}, // Generic / mismatched hosts: no slug. {"explore.lux.network", ""}, {"unknown.example.com", ""}, {"explore.zoofoo.network", ""}, } for _, tc := range cases { t.Run(tc.host, func(t *testing.T) { got := f.chainSlugForHost(tc.host) if got != tc.want { t.Fatalf("host=%q: go;t slug=%q, want %q", tc.host, got, tc.want) } }) } } q ~x�oϠ  pݓ 4\֓Uݓ 2ϓ "L"E GK ZKDMUMtS tRS0WYZ[B<xxC�6NuvfɆ)՗\$jV&100644 go.sum�*d9iZi0싫S74$lx;Gw FÍ3�FP x;i| |ܸ7s�C\4@x31�̒$o>\Nߍ5wO~Q1y XIfz^~Q*Úy8;n8ūhvМs rq uqMaJ>\h/:ǦP\S2sRvo-(87UlPU>ή~ dlH[*miJ_@Qx,W=}i}ͽyBb|[Ԩ25zVE3 WG_gkZ^iL繥'Z33R+s rR*ssV ڰl1qإ”=,nf"sE;Rx{,/-3]/=At5G)a ~tq*J++IK)k;εI-GS_Z\R{38PLyvw|Go*g;S?=չť W:B̯w1Mٵ޵^̅Țus:[_=v~Q!lVe`^%vW/7ĜTȥ_;\(ń/rh⋁ T%cm/YENPk=5]7}O+զgUoutƨY?̺R胦 s4E =(r^Tfo6&LP\YPRpjɗlUm[:]7AU$d&3,<%Y+6-j]1P86c`5!pJ+BLBVwoV=3Emn]J=0EeE O9T>{o5T�npNxC�6\ zhyE100644 go.sum�{BETD 7jxǒʶ-ڿ_q ޽ @$It^{|KJkJ{s^(9f3vϪ ȉF i!p0(;뻡_1rw>w&7[h-Um'YMLgQƺ娖]Fkuo, u~ [uĽs6/ 5AʫUU?�8O ?[YRC&ݹl#Fb&l (y|X^'"[io],"Y*X.M |_(ݾń�zzwzɘ[n)~Qs6 |Pf9f$W|v`}2I/ssRaX^Yg}8~)kD~"? #qzx4N\SӸP+X]<܊d˒gaŜ}RmƊao<{hb]_ȏ=)z9}fJPV\*3v?\UH hI|>iF5!.cZ|WF#:u�:L򤮫Iu:a|7IO*0l@!Q?KTf;)ت4@gislW BxfE^d'Jxp_Gh m�9?t~#Q`ӫZ>}.%:0U2N&sqth82Jlt׫J# y_ǒ|A#O%E$4`0|>PZCH776wgHP_Z VeƾiU\ԽYu8rʑ4!L[G.$&eZ+& B.*к˙v3[ND0+^v1,`n.@⹬*P 6lC7ܧh.OIl% z1Uyokґ\w֞z`M1ݭG!t.vV]?{s*:yBBVstʋl1εu6ub2v6ιFb (n:WNg;BdRcW춁q8oGǫlgɓy(!u\u(^ѧp؇.ySZT\6j6PײJai(t8{}b4﷓"yYjR"n2&Xͣ3uD^6#<-<9ExlC=muΒ芰̳vLl7w2J LYDm>ݴ>^?Cu[WP0]mqS?Bi&k=8 qL!6@{mfn\{ oO<=Yu^h)a7̫GL2L׾BOy 7)-m rBƸ )ٰ<\vޱWs&C9Z| q2cXV$ڗ}9_7:r)|ȰgƻS2'qQ]7-b;V\"/~ XKҫ_3o2Ŀ�F0pJ`]EBs~4Hwz9t1EJܙg1R++X Q>5t-%"&1 e,|Z/xdm$LťфA93Vn}2M8$V T 1%w0> G(=ln}5dPuAO>C^XhQ6'#|{Qi"0 )LN>yvp K1`s#:CIgІUx>2ynGCߥy)}`xUء'^(Ӎ xsk }RrDƻP`0jIu$nq"~Z=ڂKQۍv0K!-i(HGw,ku&+Q㎟dqEz-Ӎ:u'wO yѰ 1x^P?ҫ|OPp;*r{fY5iPHdQVNI+T;PD&|ɣ^Y@@%n!Lډjc8nx SAlslE*7 ]z ƒDZLDÚ4?q e6 (Vx t`{FxC[A6蒨 C>luHCpcq4`kMd!3R## "8Ѯ"+g>LCxSTTҵPr+6vuLO|Ww"|h,mIi_2{+!Ԧ>}%Z5l=brF66cYFCImsEY7^mwR!l.$vO_b-OQ s()['xg ~o5[򧒬X /( Y 'a8&qF L[?</Q 6VӍWev= j5JMxٕ:*(a8^ԩߩF:e]U%1îwX vn_oEʳoͤyOU?mH…LgcIUg7{_uZ(LDt_Dzm`&x{=74S�+A;-n mTE+66`qissntps\*I~{o ͊cDG܏{˜W[+2vg[gqiXb1:.^0U|q7ڒ^ ]I*Р]q ԜHj{$ُm#&NzI[~C]gġu%!׮NX$B4# `)tB ߘ|=gҸ"TbQp4߃}}+?!ftA׾<`y5JЌrʬʹbmYK~58-_Լ 6U5`+uZ֢s²|כ-WN�6y:2<ŸM03i{D3lEO23lɿ^%`X0ߔ>kWVe79hs ~#tZF+ (<#OPNs9cؗ$uDU6&,])e東=/V"^[{:n)yvk"lta&]O x˒6˄%-J' 5� 1JMh"m̶Uk:V:]Vd9v9)#cS,&B67m# 뮬>Mhu"5-gzDŽ4_nAKg@.,t{΅d&- &֋{$k$~Rb'GőyPZ"\T\.#AD[6e:[}s# F2]2]z;q_fUB?^FOtv>Cw>(ypeT4X':Wk\cGWTr:B!ɭ4sNcvIFG`\XVO(JRd-.8,jDzFm 1&,bS󾗾[,zD_pf(Eqc6 ]EUяt_[3+~TAQ&ݹHN%19\ &ߕGnh^A}vxp Em5Ԟ|L+Չ(Nq]vÀPՑxpMUt6%QtNg V?o%wDvE3oWCG0G|Xݥ1:w�5xc}lq \q[BצڏbDVQnl){qE4.>fV -@O-Lɠ£_w3 dA , W{ Ďb\0 }P Vl_"a%69Xy`0 v}ݗ]E@oB0Pw3ӭ&L#Tu'_g;1nEfOǮ$J YULnfg V4k3ieӁ`D֎R BOܜoq̇$w꤃@A�~xA \~D@T2ݑuʤRcŰx1sH+ \leY;'Vюts#;.Itc|7_#|J)n"N|-l̬ݰGMm9qU3 $dx dk緂 wE{8Ǧ=Xb``M mEzpvAx^ 46q7[iըŠ\@u\UE[QJ!sķ|s e=ŃL$ maq&ʻC9>@7ēmd Փ&COG]�&=%};ڊ֧${AP _ϔkk:nWyY\0<�ԏ�&C^y3bp:*B?/R+ \3O~C]_mbVT!ƞveQ[ӕhfKޥ'\$8~b.NMUuUAK d,e_x7?c\*'蒧:)!B~ rНj,>|F+ڊb{|IX'*= pG^ 1w#چxiQ\OpJȭKegq<ν S=C#nw{U(1I]8 ~aL)ƃ$%Lj)I]n۠_wsN{r4 w|,\W)OjS >*Vj#a ٯ+7~Nx~e8m̾>[c Ѹh[ͻO@w ^oü>@@yڜ]vt9 DƣZވb9}|ЯW/g,눧.ݮ>C젮 uÈ<&h�ݟևrrvՖxaww҇CSP ]I~ʟk7:̙ BC`b83H4/#}NU+k iN@1%)|N~>Ǥ0-ƍgyW K | 4x8?�WޛpvHn^GB Y/t)v۷v,w$䅗T@4jClv‡ ~iy5M&VpZ nY? 8Ŧ:®Y{}+mua,/!Q_C4̵YrX%Ih|waŖqpJyspUy;%)d< ly#l9XI^{8"0Ķ Gd~نoH+jA%Z ZpDh~v΃<(@(;|d}j ;ݑH3!}̚+/)@Wn5&ܸj+-Cq"Ҷ;yZ|e{hQK(1m-{6zGZQ RN޴l#5%ϣ'DzUR&}~ c r׳rq9K}yqHmoG% \hF}~oWD+]gQ'K7Dۡ=伜IOa5TEχG@όɏ̓edd CT;s]pԚeowSh+ ^)/oh=pօ1SY"} ,}:f_F {5p %07(AalDg!Ce? kE/ZG4Û)ܜ ݰg@!{b;ͺO =~>7aF )lpZ%7!œeS0\íHZv&Yãx Q;?}vxcd(.@ |J#^88mb%h|x mEѫ(Qt b5اGQ"1+_x7?i)ϝh SeH٦L>]: ֡o(VKI3\pZ=kY$.vux8;6}N0gHx܊$-Wg wV3v/ Pvd"~ߝWΓeE#{]9F܂g}lD=nh++c!d(xC&`4S,7 .G֞^J<>Ӊ>(^S;ЙEoN P9ԎםxuYk?^B_|ҁ;s~ $J KPc]x3 BV/TȄJ-V:{"4.XDa:qU4V@qiz) i؋n _Knkx+B7Fz1t�ciqaԶnkE^p{k `He2^/̝tb/qb>fC8'^.14 Vv=n;ãp>g 3.u .gfK!HV/=2pd'_ң@\Yl,Dß+`,kmtl+rҰ!Pr&;+Qvx\=X9%QJn/?]/@ZlMoIY(l.41xd z׽;aM؊`Za. N1|Z ؄Ȟ8$}~) o-Fg\<"\O^y}Zݺ=+-ξcc<.맪/!I{swNQ:/dilK ߘKMԵ1/ݽPӗw͐!jSf܇vq2o%nC~q(K\ }8? ]db\VUlH秥A3&Ȥ?(zؼ Z.6 cqQ0ѕ\WЯd^H 淉ßonxUQaOl4| ܶ)|TӾq _1N[V:�OA>_d3Wn%X݌Wxx"V8|X7ːXv0艰%Ң^JDԭl] O`7J}f ЦX-a괈B*!uŇFCG#J�޶;qPXg$J0% 9F�+[AfϝUx}PmڊwL9Ƹh7bP j&$G&tBV7c� _3u單&+qHǘw^ߕ[:TGX|#dKWT#,pCo Y0w z�\ďGyߏ�O-6J=h8ޣU}T^ܤGؗ# KQVg˾ĨkTn u_?>_p u3É !:Pn-wm XߘWrA[DI¨~G'zw폾JPЪDZx:5RjӴ^d{&#PtlS֋0?@i�#$?ǃ]ȫ@uS).*Kn(*lDSj',V.SqkZr[-JUxͣAV*gS׾@@ WSr 2k_S+7ЊXtVəݫ 79lwCh`G/w"-U>?O._Łs(m7Ӎ)!\Qi e8IIL_VigIEiFDqdUw'#`q@YՔ!"x\CV؉t LEfI:y ~" yܵWi6Qnrb=U9%hC=B0衃lW㲊Mm%dW_ &+DۈP_4JTŻq޺ oNt>3UAÒn]]A ?fg=h�9(Ҿ=ah|<\M-]OH#Ҭ{zQn𗬵t̕MIxo)K }kV9hB@çۅ5K[EuPSck7.,(O:dsᱸ} (U=hRv+;U&(uf0dJ ɹ{5zm=jB`Z.!sN2ӑ+!K8}Qf%GKwّlw@W嚊 ~j*-WJ!]=3A~N.TAihXciyZHaLCyWqO5p:qvF 1 tWO!ziz Rְp>[̳cX'jv]ÿ:SEBbmSN� dZo^P99ԇ Ѡj]%ۃү$|5` 9WIWiF`m;(jZh'LDOiC yVCߪDM'5EN\ 2ZV6mr@yaOBfWHiȳjeAz:n3ɫ�xZC]j4 rvKu)`0Cv|;Sx:O4ibщ$.vJ5pBv;V buw쪶9uEY~Q9ѼG)61oRbmG~\]]דyrgk'S(-ʦ1pxQ+]rDm]"]kX3hW4מ0|݀T\6I|L*uU"k#0)>p[qaե ;;#".w/~#rE۝r UKpISZ;4i{i<_;Gi�b4J| p"}eIg%KlTbT4迁D4|ԕȩ M@TZ=4;3-̛j*m/% r:/x%~D#qNEdNP~e=Vf ܊ad/@Ԋu﫹@c*7KTha^3ߎN7#ˆl6$U69[<&6 5I_A/ɷx +w\]0'Ϫm{:Ŗ7pz#E@|QhV-ق4_ʭS�D LM9dܢjC|P豱;x6px0<kdgZ^oԏ#5Rl|Y#TR\B %cϷ?cJB'9�5s8G<.ccR07Ϥ$ŶCد`!]Y}ZU*ƁQϿ<�'?Ļւ3cӦ'mN,Lk<}[t�簚`M(oB@KHݹQKw.3T.TʠzM9zxQQS^ͽ<S&l&W/4#f}u%r &h#4&�JSIbW7(SЍ z>7믐NPo&.Ox<�\e(AZ*ͱO1'Ogy  _| _:noqW|3FRP~@~9n4Ӗm`xX/cOp`qZj#Y֚6s"A.G+ҠI[5*rĄmwԁ1 ܮ;rϯ!y xK]m KA ΝDh *«VԸ$##j{rRPd bS+_`XyaFG�Ua5rwߑ0wvnB;?b/W8+ZRb8آx7oo\-zKD Jsv'hY :6>~}AOed9$Uk<7B,ҊEh5'yPfvMNb`)? &**·ic9{"#avv?ʻVv2[}FG;hg:FrҸs4H@�g47UBJX�#> q.8=I0o_ w;›ߏ~FwFy ݘ9,Vbx1{)΀{/ gш_Az3ښ~P\_r,qZǷOXG.Qx~Q ׌0hp@BZu?iDF0$ |q/ >GzNV:=xøvC#)5?c% &[-#I9Nm HMmT׵}~�a_J8u h]/vQhomG8Qkĩ$ E1Y᭻NW]/4>vޗe3_- hE & bOrH{c̎$ӑKos:L8!ď%\%uP=s>hۗԨ7GjnF)uXvsu(|*0N"A�P pyي$E, `p"^w7R1@") ~x�댳<`?@a0} )YzK,@nxxk +'}Ѫ/<$WZ߳P`,ySUUۼC}5 (B 8v^ԫ~wn HN}^7<ܩT7C` PR a_5F…TK* ̮Ws.݀ewj,+}=;08h1*tõ?{,$f˗ Y _}ǾZeNk4[m5ҊCt:&Jh+#X2:Xsa# \ۿt-؟0]bi:g\fgd5M^kj5 Rp=q[ Œ쀩Q_4zրU,m�W& x,-`ņ;8JY-.}1|qY ܾUka_Uxk_tVNڸCL93gO|o(!ۜWԷ)]CMhL�?v8M]5x諦%֮lYQd~<=29 2~r{9VWGz:Q+I;^}:7(M®H1^r|]ە<ΎVpQl6*a;M2~{phj~]t_0tt|Oǯ4pem8@_ &<Twwa@ƞ+Y+rkqz t+MI>4YcP�Q)7пlk抷ٕN;wvôo.=u͂lRc:GIU9 %uKڛbZ>Q W54 C%fLYko\Ń�IRhC<.-cth,6[X[܍H�OD %oJ j̯~" k%}yA0 ?KPp̛8 mY ٛ�0Ҷw`^tg n= +Opox¡d39.{l:N%e.VX kea5zƿU0|]U + a"#G TôB[.;1Z$(vCɴ!x V:͂L+4\GF**PnlN(ĥIG?0,3i�E}*GqaaϻQʲms,ܕ #v„8g]L^&pf/yrL[,0-_ɓz38q84PC|*&SyuN~)\ -D~jk_80ԋ!csD6ZEJ r5]}8lAܓV٪h}LIȬU[m\,a-Q IJy m$oYKMw[P2u+ΰt7j-22YM TeMęxHZkvW8\7K!MYXြ:Ž\Rl~k }X|S-4~oDE7ca"X65Q1g,\v͝Qq&?v١" <z[S$]>rl6{tk,JhT;vϪJӶ8oX}k0@oྪĊGBkVE w\Vi16_"B3d'U#A׭p@&;Kz!WppE؊ ,m|b(=%eHM֜of\L`ץ[4љT=! zz=.qXN2HU|Ռ[& 2cYxJj yıX=e+GijaBVa/f4LB2,ؿ$@c:h]Cǃqگ˺PtC:kY`d->IAȬ,fm]"pZgi3iҽSf6*P R}~C@Zh(#,KbQ\5U5c;Px@ A{T廱,˻~ /Yp]�utQ vRb$7"Q7lG)cqh»Wn禀'b_ XbȕQfV\ٿoPU%bPf1\uRt6g6_*t4•:#ŗdIS 5jrMeYQ_sT&BL΁fO:x)0u?!t~FO !*#x}O`#Vlle1~޶�BAH ?1ʨlA ޓ�'oF/Fiϳxj~v{EmIm&8&1-)$2K /. x$0QtobJQܩu3wum|82" \0NmT$9O`VI(FMK|V$"+L&[XgrHI1Cajviv~.+gC-oن l-aZl~T!0K0BZY@�R$0gZg%"|{#֌~tRͲaY ')sz`g\g!MM^ cΖ!Z Ş5 mroOf:|֣V*"@!*)'¨ -"h\jtMB=;7`Щ uUѭvքvw: !z3>n7YVc*?m|1}9x2R'ΐY?`0u0�K&~ Jehx!b���~}zGP s u(Zq݀3oEMVӗf@'롍>nCh.hD0Y`;F OW9j HfZ։Dž7&f2UlEfۡDTXj̰v(?l:a'Nlj d b04H e:f зӼrnBSk[5l^Q3Hx�--10! 7P x]ɮxE nUwUAU^!dNmGם f&ŝeW,=v:ca? 2 f|'n:1;/3arJGX78=]p;pO-V6*OQb*$YtLǷSoc(ͫ$N5Tы"D\)_w TZn:%,ed[d8$hSLj|t&<+*fP#X0f 6S{ H= c4KNß0y^.SW /v:*X2nkEpf1C|sT?o?:z&m̎ˢ͉5<͘@ !;Cc#`^PܨkQwxg{~[`:d<[N#,Lb\#%n@`jpd IB̤8c P5ej<_U=,*YˠVRdA132E6-p'F'BCP3\-NJ5GtM|ѭb3drURbd2ɀpMm;FG;c]eMnuo58̔e' ]ۍݛN>x!^^yuCs;5,{(~,MVK/k[Bw+ʐLs}- ÷# h]6?`Onk[ND]e랗0ݛj 1N"RMQky:%b㧑C0{.n. ^7 FBX0&nl`h½ŰN^}pae|&ǀhIA@M/'ۇG bZv+|9sn(PsZj7.a0PkƇdMS)jø-Z9qc(^@Zg}_+q+Vqld(wk]&7;3x-VK$. |f \ 54*!U 1AoDO!�gD?3]qNg͒53_P|hB v3]tӕ碭 ֺ,u3J89GB%N'!o(fƷxEDc"PNgBjILe,Jx=A^ࡱzƨ輬Y#2%ɦ'{߃s-uM[:z{tEx'Mu|M#_0I² Ese]UyS$5Updko3_A Vgdƥcd$МX@g}2:;$BڼF0 5y2x`NxHg@E%'1..E݈ /KRl|ixO�CoC 110 h1:RU3i0JVV8LSFAFlSBeQS5CsupK273cDs+jAcKqnaKEYq=oC 10{CJ+l%xkŮdb� z%I j ×S~*`yƧD_;7Y' e8yg`eM LL33R+s rR*ss,`^6>&aƵ.goMcQW\ ;_]:s,+OJ U H/=* "ug”�T#(@xZߝE~J&70$xQ "R߄:odXZZTY_2aWkv#vȮ fQ�2xC�6[7|>hLSt100644 go.sum�ͨg"Ӟ)l{^DW7u#Rx+�"40000 .github�}L skB3(*Èdx"I'9x!�[)9CuIq!% /xC�6'by^w#c%}100644 go.sum�ԈT7׊eὭz蝳7 8QxS�@<p\<>ؑQ]TWȹ; t>ӂƠ}YʏO6<Nl%ax�w׹]4HH?7bx[rH}A]5$5cjQ~p8l(�u"i#uc?adɪ….="P:y2+Tyd[[| :q8*Qd|M[gLYY.wnET$LY{yg1\w:Uw(<*l0ͷtR8>]^MΦI9:3Z35G&Ytᇚ2/n˗PD}1W4/dEuz~pbokk0P{3pEb h~Uδ“1_*zdj2ZK͙P818L%*q /~o&]NoOUª?ץ6%fEq^z\>IuS.eTT�YK' KˌǼQ[LW9/\ =/d4Ne?p^5�YKmC'X̗J##w1e(3 `m~-ĖOOzݸÞԦpJA7ˑhveXOeZ17$R,i�(yVOU$WLGy9Rv|bi6Tf:԰$_e4AxCcL~q4Ȍd<^y#Sq#xer5Js/ts%pY~V�AQ t P'UPF\h5˅[.]A1[7[CS> ogdձS5{7lչ?DIƶ 8c}bc%MT]ycn5 � ].L=^y76vB}<[ѹ6[Doܮ(QOjmu5ajsr$Y8U4)Fy9["zn G+ !HWv) D-jgI2h Me-)!)fz`�M]5s=,#qY;nC7<xBu6\J\- un&HS5*P@^R9=-\_2yp /iޞs?pwi�ҫ[t{G+Q7emmhb#Q&>chOy {h|i"%- >~a_$sDYj>dY7]JmHQo P4hW bȯ}5Ya+ Μ\VPLbDLE)_o0Q= {;_ܵ)c۵^y}D}+`|Q?R*FO?]`{S-:0E9�0[GǦ0, D7,7߰UeJP!C=~MNeWun 7)hU/ )*CK `xX;b?4� B&S5F�u2.б!g@#H0a"N m O@pwWz0\_{sRb3 fP[$4V\u:ȱcPmq|y Gy$ 62 8g&xzӯ\:chB>~j}ދi!E&Ut_G} ?Z"`L 9VϭVaHAEX� ݿw/eF װl ֐ U$\:94u;AB|@nz&Lg,�H5xdej�Xe�SZA8}GF1[JxQp~pX\Ff8 R<#S8;N]S[vt"iGw,>"zu//+|Ϝszw D|vvrb2Ƣ@w,Arpu92^}Vy6U)NJWodX]Uk,S;I}~pgyݾ3+=waă|s4^XkH,'nm1j)n38Lq~$Ǯ#$%LKl$""ƾy5$4ܖ_4ac%IU \]b�MIeV # 'S65%*]N7PH3v!o|q|N<2. >R>qzI:>5MsW{(ģҪSqwx`L,xSoN)9.P*a]Ozu2'D) bǙSܨ&V.= b k Jz9]X" MKM)7pEѐqP^?x~'0:7*?Fv5r6>f04{*J_ $ Ui %Sek/٦dFX(Q/_mW_wx'Ɍ# (33 '@FA"d/0 5:[,P eLG 0l.gy)k [r}޻Ox] EBL&$IL2^pr'iB:M6%"l^`($h HeOf=sgԊ B^Gq7'(tHeߘ諩RemԞG" kJ>{HBkE\ssݣڎ+atzA^^H1OOaKWm^/JF":-hC) Xs]ق.~Gs6gAZiwQ~}o :@;񣯷+N!lu-yr@Cx'E7Ykzdnfv 3?ж w~j{l6R>~y} GBWp}gωu2BpEe+r;IwD<*"|zya;ulAU$V?|-(ۃDW p i#$\%rgd 2$+\ IR턤Z#Ip)9K4{;MaDtкq(9CV:8?=uw}We;0ʧ4>~.׺BZ2'g̚$2j-j-{+_mzu߽|VEMJYo_T[3U¶^l^doNirJx]\Dtdy%26'.Xi(D3*2NծRA}jJ)un)pˤhwg-en9Q@ C;6k8#6' $s:~3Ӭ !*_جoBaX 4[ja<MV'|w}FFy Da8 // indirect %6.2 // indirect %signin v1.0.5 // indirect %sso v1.30.9 // indirect %4 // indirect % 6 // indirect 1 // indirect  // indirect ?0 // indirect Z# // indirect " // indirect ( // indirect ` % // indirect ! // indirect #" // indirect # // indirect &4 // indirect ) // indirect ,mux v1.8.1 // indirect , // indirect .$ // indirect a//  // indirect a/* // indirect 100 // indirect 1! // indirect 1}1 // indirect 1vfs v0.4.1 // indirect 2* // indirect 3@ // indirect 4% // indirect 45 // indirect 46  // indirect 9 // indirect A:  // indirect : // indirect <; // indirect < // indirect q= // indirect q=*>  // indirect q=>< // indirect github.com/luxfi/crypto v1.19.17 // indirect mA 3 // indirect C // indirect E // indirect 1G v1.4.1 // indirect 1G  // indirect *H // indirect H6// indirect github.com/luxfi/zap v0.7.0 // indirect K // indirect L- // indirect \M& // indirect N# // indirect P // indirect %Q! // indirect Q  // indirect {R# // indirect 'S  // indirect S@ // indirect aV& // indirect W // indirect [, // indirect [[ // indirect [\ // indirect ]$ // indirect m^A // indirect Z_C // indirect ` // indirect Ie% // indirect e // indirect f" // indirect ngE // indirect h // indirect j# // indirect l  // indirect |m' // indirect |mKn 3 // indirect go.uber.org/mock v0.6.0 // indirect ]p // indirect r // indirect r3 // indirect s // indirect =v5 // indirect golang.org/x/sync v0.20.0 // indirect y // indirect ]z // indirect | // indirect #3 // indirect gopkg.in/ini.v1 v1.67.2 // indirect ʄ(3// indirect modernc.org/libc v1.72.5 // indirect  // indirect a // indirect } // indirect ) x|u-c2sp.org/CCTV/age v0.0.0-20251208015420-e9274a7bdbfd h1:ZLsPO6WdZ5zatV4UfVpr7oAwLGRZ+sebTUruuM4Ra3M= c2sp.org/CCTV/age v0.0.0-20251208015420-e9274a7bdbfd/go.mod h1:SrHC2C7r5GkDk8R+NFVzYy/sdj0Ypg9htaPXQq5Cqeo= cloud.google.com/go v0.111.0 h1:YHLKNupSD1KqjDbQ3+LVdQ81h/UJbJyZG203cEfnQgM= cloud.google.com/go v0.111.0/go.mod h1:0mibmpKP1TyOOFYQY5izo0LnT+ecvOQ0Sg3OdmMiNRU= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10= cloud.google.com/go/iam v1.1.5 h1:1jTsCu4bcsNsE4iiqNT5SHwrDRCfRmIaaaVFhRveTJI= cloud.google.com/go/iam v1.1.5/go.mod h1:rB6P/Ic3mykPbFio+vo7403drjlgvoWfYpJhMXEbzv8= cloud.google.com/go/storage v1.36.0 h1:P0mOkAcaJxhCTvAkMhxMfrTKiNcub4YmmPBtlhAyTr8= cloud.google.com/go/storage v1.36.0/go.mod h1:M6M/3V/D3KpzMTJyPOR/HU6n2Si5QdaXY Esng2xgOs8= 00h1:p575VVQ6ted4pL+it6M00V/f2qTZITO0zgmdKCkd5+A= 0/go.mod h1:EmAN849/P3qdeK+PCMkDpDm83vRHM5cDipBJ8xbQLVY= github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.2 h1:Hr5FTipp7SL07o2FvoVOX9HRiRH3CR3Mj8pxqCcdD5A= github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.2/go.mod h1:QyVsSSN64v5TGltphKLQ2sQxe4OBQg0J1eKRcVBnfgE= github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.11.0 h1:MhRfI58HblXzCtWEZCO0feHs8LweePB3s90r7WaR1KU= github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.11.0/go.mod h1:okZ+ZURbArNdlJ+ptXoyHNuOETzOl1Oww19rm8I2WLA= github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 h1:9iefClla7iYpfYWdzPCRDozdmndjTm8DXdpCzPajMgA= github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2/go.mod h1:XtLgD3ZD34DAaVIIAyG3objl5DynM3CQ/vMcbBNJZGI= github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.2 h1:FwladfywkNirM+FZYLBR2kBz5C8Tg0fw5w5Y7meRXWI= github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.2/go.mod h1:vv5Ad0RrIoT1lJFdWBZwt4mB1+j+V8DUroixmKDTCdk= github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2 h1:oygO0locgZJe7PpYPXT5A29ZkwJaPqcva7BVeemZOZs= github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI= github.com/aliyun/alibabacloud-oss-go-sdk-v2 v1.3.0 h1:wQlqotpyjYPjJz+Noh5bRu7Snmydk8SKC5Z6u1CR20Y= github.com/aliyunZ/alibabacloud-oss-go-sdk-v2 v1.3.0/go.mod h1:FTzydeQVmR24FI0D6XWUOMKckjXehM/jgMn1xC+DA9M= p 0h1:LuT2rzqNQsauaGkPK/7813XxcZ3o3yePY0Iy891T2ls= p8/go.mod h1:IvvlAZQXvTXznUPfRVfryiG1fbzE2NGK6m9u39YQ+S4=  0h1:zWFmPmgw4sveAYi1mRqG+E/g0461cJ5M4bJ8/nc6d3Q= 8/go.mod h1:nVUlMLVV8ycXSb7mSkcNu9e3v/1TJq2RTlrPwhYWr5c= ,0h1:iu+64gwDKEoKnyTQskSku72dAwggKI5sV6rNvgSMpMs= +8/go.mod h1:MI2XvA+qDi3i9AJxX1E2fu730syEBzp/jnXrjxuHwgI= '0h1:Jp2JYH1lRT3KhX4mshHPvVYsR5qqRec3hGvEarNYoR0= '8/go.mod h1:fZG9tuvyVfxknv1rKibIz3DobRaFw1Poe8IKtXB3XYY= d0h1:I0GyV8wiYrP8XpA70g1HBcQO1JlQxCMTW9npl5UbDHY= d8/go.mod h1:tyw7BOl5bBe/oqvoIeECFJjMdzXoa/dfVz3QQ5lgHGA= Lfeature/s3/manager v1.20.18 h1:9vWXHtaepwoAl/UuKzxwgOoJDXPCC3hvgNMfcmdS2Tk= Sfeature/s3/manager v1.20.18/go.mod h1:sKuUZ+MwUTuJbYvZ8pK0x10LvgcJK3Y4rmh63YBekwk= 0h1:F43zk1vemYIqPAwhjTjYIz0irU2EY7sOb/F5eJ3HuyM= 8/go.mod h1:w1jdlZXrGKaJcNoL+Nnrj+k5wlpGXqnNrKoP22HvAug= 0h1:xCeWVjj0ki0l3nruoyP2slHsGArMxeiiaoPN5QZH6YQ= 8/go.mod h1:r/eLGuGCBw6l36ZRWiw6PaZwPXb6YOj+i/7MizNl5/k= 90h1:WKuaxf++XKWlHWu9ECbMlha8WOEGm0OUEZqm4K/Gcfk= 98/go.mod h1:ZWy7j6v1vWGmPReu0iSGvRiise4YI5SkR3OHKTZ6Wuc= w0h1:eZioDaZGJ0tMM4gzmkNIO2aAoQd+je7Ug7TkvAzlmkU= w8/go.mod h1:CCXwUKAJdoWr6/NcxZ+zsiPr6oH/Q5aTooRGYieAyj4=  0h1:CeY9LUdur+Dxoeldqoun6y4WtJ3RQtzk0JMP2gfUay0=  8/go.mod h1:AZLZf2fMaahW5s/wMRciu1sYbdsikT/UHwbUjOdEVTc=  0h1:fJvQ5mIBVfKtiyx0AHY6HeWcRX5LGANLpq8SVR+Uazs=  8/go.mod h1:Kzm5e6OmNH8VMkgK9t+ry5jEih4Y8whqs+1hrkxim1I=  f0h1:LTRCYFlnnKFlKsyIQxKhJuDuA3ZkrDQMRYm6rXiHlLY=  f8/go.mod h1:XhwkgGG6bHSd00nO/mexWTcTjgd6PjuvWQMqSn2UaEk= 0h1:/A/xDuZAVD2BpsS2fftFRo/NoEKQJ8YTnJDEHBy2Gtg= 8/go.mod h1:hWe9b4f+djUQGmyiGEeOnZv69dtMSgpDRIvNMvuvzvY=   0h1:M1A9AjcFwlxTLuf0Faj88L8Iqw0n/AJHjpZTQzMMsSc=   8/go.mod h1:KsdTV6Q9WKUZm2mNJnUFmIoXfZux91M3sr/a4REX8e0=  : 0h1:VrhDvQib/i0lxvr3zqlUwLwJP4fpmpyD9wYG1vfSu+Y=  : 8/go.mod h1:k029+U8SY30/3/ras4G/Fnv/b88N4mAfliNn08Dem4M=  | 0h1:v6EiMvhEYBoHABfbGB4alOYmCIrcgyPPiBE1wZAEbqk=  |8/go.mod h1:yifAsgBxgJWn3ggx70A3urX2AN49Y5sJTD1UQFlfqBw= 0h1:0jbJeuEHlwKJ9PfXtpSFc4MF+WIWORdhN1n30ITZGFM= 8/go.mod h1:sTGThjphYE4Ohw8vJiRStAcu3rbjtXRsdNB0TvZ5wwo=   0h1:5fFjR/ToSOzB2OQ/XqWpZBmNvmP/pJ1jOWYlFDJTjRQ=   8/go.mod h1:qgFDZQSD/Kys7nJnVqYlWKnh0SSdMjAi0uSwON4wgYQ= !h1:VbyeNfmYkWoxMVpGUAbQumkODcYmfMRfZ8yQiH30SK0= github.com/aws/smithy-go v1.24.1/go.mod h1:LEj2LM3rBRQJxPZTB4KuzZkaZYnZPnvgIhb4 pu07mx0= A0h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= A8/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ibhJ6rlkpw= m00h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4= m/8/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM= $0h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= #8/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= #0h1:9GPOhQGF9MCYUeXyMYlqTR6a5gTrgR/fBLXvUgtVcg8= "/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.1 h1:5RVFMOWjMyRy8cARdy79nAmgYw3hK/4HUq48LQ6Wwqo= github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.1/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40= )0h1:I/w09yLjhdcVD2QV192UJcq8dPBaAJb9pOuMyNy0XlU= (/go.mod h1:0KsrXtXvnv0EqnzyowllbVJB8yBonswa2lTCK2gGo9E= github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da h1:aIftn67I1fkbMa512G+w+Pxci9hJPB8oMnkcP3iZF38= github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= A%0h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= A$/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/go-chi/chi/v5 v5.3.0 h1:halUjDxhshgXHMrao5bB8eNBXo/rnzwr8m5m36glehM= github.com/go-chi/chi/v5 v5.3.0/go.mod h1:R+tYY2hNuVUUjxoPtqUdgBqevM9s9njzkTLutVsOCto= ;2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= 0h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= 8/go.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= 0h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= /go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY= github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE= github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE= github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= gi30h1:haMV2JRRJCe1998HeW/p0X9UaMTK6SDo0ffLn2+DbLs= 4/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc h1:VBbFa1lDYWEeV5FZKUiYKYT0VxCp9twUmmaq9eb8sXw= github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI= github.com/google/s2a-go v0.1.7 h1:60BLSyTrOV4/haCDW4zb1guZItoSq8foHCXrAnjBo/o= github.com/google/s2a-go? v0.1.7/go.mod h1:50CgR4k1jNlWBu4UfS4AcfhVe1r6pdZPygJ3R8F0Qdw= :0h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= :/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/enterprise-certificate-proxy v0.3.2 h1:Vie5ybvEvT75RniqhfFxPRy3Bf7vr3h0cechB90XaQs= github.com/googleapis/enterprise-certificate-proxy v0.3.2/go.mod h1:VLSiSSBs/ksPL8kq3OBOQ6WRI2QnaFynd1DCjZ62+V0= github.com/googleapis/gax-go/v2 v2.12.0 h1:A+gCJKdRfqXkr+BIRGtZLibNXf0m1f9E4HG56etFpas= github.com/googleapis/gax-go/v2 v2.12.0/go.mod h1:y+aIqrI5eb1YGMVJfuV3185Ts/D7qKpsEkdD5+I6QGU= github.com/gorilla/mux v1.8.1 h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= github.com/gorilla/mux v1.8.1/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= github.com/gor0h1:yC+LMV5esttgpVvNORL/xX4jvTTEUE30UZhZ5JF7K9k= 8/go.mod h1:uNpOihAlF5xRFLuTYhfR0yfCTm0WTQSQttkMSptRfGk= 8A1 h1:JeSE6pjso5THxAzdVpqr6/geYxZytqFMBCOtn/ujyeo= 8A8/go.mod h1:r4w70xmWCQKmi1ONH4KIaBptdivuRPyosB9RmPlGEwA= $0h1:uHhahLBKqwWBV6WZUDAT71044vwOTL+McW0mBJvo6kE= #8/go.mod h1:lTKmG1zh86XyCoUeIHSA4FJMBwCJiQmGfcP2PdzytEs=  =hijri v1.0.2 h1:drT/MZpSZJQXo7jftf5fthArShcaMtsal0Zf/dnmp6k=  Dhijri v1.0.2/go.mod h1:OS5qyYLDjORXzK4O1adFw9Q5WfhOcMdAKglDkcTxgWQ=  *0h1:A8YM7wIj16SzlKT0SRJc9CD29iiaUzpBLzh5hr0/5p0=  )8/go.mod h1:0JOYq4oFOuDja+oospuc61YoX+uNEn7Z6uHYTbBzdGc= :tx v0.5.1 h1:jWamJSHg1RtvcarevSJ/W5lyPJfRB4vBYXDuxyyOup0= Atx v0.5.1/go.mod h1:rWgoDyQiB5d+GOGYncKrQu6uS7Gnoh0xlm1hCU5rq5E= "0h1:NjK1Umwaxb5lnoFB44iGPtGj58y/PLucNcCc2gE8q4I= !8/go.mod h1:/iX6TGHL94Q9MkMmvHKKHlyopHn06RjEW7Bz3h6TJEk= $0h1:PulFMIVVbvxz/LmBSKlj/o+T7nZmPGd2L2YjYVv5V1U= #8/go.mod h1:U0WdEoFFNw4lS9CRysXtsWOqtkzjIi2Ggv+C8Nsz8+4= 0h1:erXat8LUZRI+fuw+8XNpslWdAaIrkGPXNGbP3PGQUBU= 8/go.mod h1:8AzyntfZgjK6iiB4A+xPestHgSAGUEHMthTkhACRIjM= *0h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= )/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= github.com/holiman/uint256 v1.3.2 h1:a9EgMPSC1AAaj1SZL5zIQD3WbwTuHrMGOerLjGmM/TA= github.com/holiman/uint256 v1.3.2/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= github.com/jalaali/go-jalaa] &0h1:lvIuaX7hO0eO3Rlev+cVnlsoExR3i/JXxu88zt4JHPg= B @8/go.mod h1:Wqfu7mjUHj9WDzSSPI5KfBclTTEnLveRUFr/ujWnTgE= &0h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao= %8/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ=  ;0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg=  0h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y=  8/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0=  0h1:sSmTt3gUt81RP655XGZPElI0PelVTZ6YwCRnPSupoFM=  /go.mod h1:D7kQaZhnkX/Y0tstFGf8VUzv2UofNGqCjnC3zdHB0Hw= github.com/kr/fs v0.1.0 h1:Jskdu9ieNAYnjxsi0LbQp1ulIKZV1LAFgK1tWhpZgl8= github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= github.com/lib/pq v1.12.3 h1:tTWxr2YLKwIvK90ZXEw8GP7UFHtcbTtty8z[sI+YjrfQ= github.com/lib/pq v1.12.3/go.mod h1:/p+8NSbOcwzAEI7wiMXFlgydTwcgTr3OSKMsD2BitpA= K !0h1:Hv4EaHWXQr+GTFnOU4VKf8UvAtZgn0VuKT+G0wFlO3I= K 8/go.mod h1:HIS3gSy7qNwGCj+5oRjAutErFBl4BzdQP6cJZ0NfMwE= y 0h1:Tsk6gXj2uKE19501bD0ajRYdeCHIlTGb6jYyLc+F8hc= y /go.mod h1:K00BcnLzEYMPHwCFq8Tf/450ApmTs9xBVvYOnofJCkc= github.com/luxfi/age v1.5.0 h1:G69HbSV4R3vKEH9B0CulnRaMdSdf4RalMgP8xKmxHeI= github.com/luxfi/age v1.5.0/go.mod h1:iAYAxgvrXxcy746+Ovh/eWWDuF9teJLNcCSSOX9RYW0= github.com/luxfi/atomic v1.0.0 h1:xUV60MuzRvXngaQ1sM0yVC2v4TRoLlUGkkH7M9PS4yw= github.com/luxfi/atomic v1.0.0/go.mod h1:0G2mTlQ6TXWHICUHrUUPu1/qAiIyR4gSZ2tva9ci/bI= g 0h1:kAzOS55/hmYeNKR+0HAKv4ma48Y6JjkI8UQeqdZ8bfI= 8/go.mod h1:co7JTxZZHpKT31Yh01LFp5aZOxmoUg157FhBLQdQHVU= Q  0h1:Yl8ZalMNkqo7cD6R9AjczAajkLOmsjyZ9+DASVYHrvg= Q  8/go.mod h1:oGQ3j6E8c2P0pL0irYtWkrB1hmDUFIE0puXHK4gV5KI= Q 6 0h1:4tEUHw5MK1bu5UOjfYCt4OKMiH7yykIgmGPRA/BfJTM= Q Empress v0.0.5/go.mod h1:Cc1yxD2pfzrvpO32W2GDwLKff+CylHEvzZh2Ko8RSIU= Q #0h1:eJyv1fhaC0jMLMw6+QS774cUmp7GK+ouMgvLCqnC7cc= Q "8/go.mod h1:Aj/FR5NpM0cB2P4Nt3+tz9+dV6V+LUW4HuMgSjwq5hw= Q >stants v1.4.7 h1:e/Qs+DQP3pugle3Zncq6fZCxKgqqtbyD/z7Gm4ZjsYg= Q Estants v1.4.7/go.mod h1:hOszZ2NDQ8gMZKncfcZ67PXkb5OIbnwAzXC3oFbQwW0= Q >tainer v0.0.4 h1:BXhF82WyfqVP5mjlNcr7tP0Fcnvl0Ap1rkiu+rq5XuM= Q Etainer v0.0.4/go.mod h1:Z3SpmMF5d4t77MM0nHYXURpn+EMVaeu1fhbd/3BGaek= !0h1:l2LLu7UFyICtJVfraLDLRi+lFGiDXKHSL18M9/m1gsQ= 8/go.mod h1:INjdZtke85k8hX/QAmTMAY8bbZ4gzGZQLqURg3xf6Gk= "0h1:flss7/VSGf29l1yZvPwazbtp87X5qfnZGPCU5ObqttQ= !/go.mod h1:S/LvmfzNYWVNslcEcZwDrntqUO2ksaL8ql1nRmLUA/Q= github.com/luxfi/geth v1.16.98 h1:w187TtKuGStf3tm2bshuHVKBv2Frjx0lT54kQ^VXyNHA= github.com/luxfi/geth v1.16.98/go.mod h1:6kEzSExdk9CPQDPXALt6P3HfQqBq7KF1Jrrv9gBpxbU= {1 h1:iapa/PB2UqLzHyAT5bM8173PfRISDJSbBYFuVcjcPJY= {8/go.mod h1:NbKTixz6Miunyh+7ER3G389mzUKV22QIVPjpcTnKZuY= 0h1:lEotq0WUpMLcc/5X5MbE3n73jdfNo8IlFvTDfUXg+9A= 8/go.mod h1:QWjJvggX/nRkmrz1AGSaF2Y6mnOvz3g7lFOzs3Zd+JM= 1 h1:DytagtI2+99jMD+4JU3MRQuLdZiZjtHOCi8ukSehz2g= 8/go.mod h1:pz5W+DqKx0La2uyq1mV5Kpi0gXXNhmVpZTZRmhw+fX4=  h1:xkUKRWvQ4ZwvlUC2e0/RTtHYZOYSMvSQ9W9lbjwBmiI= github.com/luxfi/log v1.4.3/go.mod h1:myIkufyiQomSQH34K981kbz6cG4WUoerRUh7F4XhlQI= 1 0h1:1t9bCCsEqnl9yIKrShlbs80DBKyYTWdnzkVfBqEeO7Q= 1 8/go.mod h1:QvbRxauQyE1w4lvbcLSe6c8yeJz2Zj1Bq1rayGgs2tA= 1 p 0h1:Vz4c0RsZVPdIKPsHPgAJChH/R3p15WHRUz7LkLf+NIQ= 1 p 8/go.mod h1:BuxSu22RbO93xBLk5Eam5nldFponoJ73xDFz4uJ3Huk= 1 h1:g2eRr9AXcziPkkcd24M+Qu9ApEpoKKjfI79QSNqv0rQ= 8/go.mod h1:dbp5f3h3aE7CGzwbaWzBM9cwdcekhmSrWhQevgYhhNA= 0h1:axPwfq+erOlIue7IJp5g+hMcMtVhYHja9gJAaT3+KNA= /go.mod h1:fO2giazkg4NDtr72JM/QXJBYebplAMeWC1JoZyNDvKw= github.com/luxfi/mock v0.1.1 h1:0HEtIjg1J6CWz+IUyP6rsGqNWTcmxjFnSQIhaDuARwY= github.com/luxfi/mock v0.1.1/go.mod h1:jo35akl3Vtd8LbzDts8VJ0jmSVycrd1/eBi6g6t5hKU= github.com/luxfi/pq v1.0.3 h1:pFlQm1+5FuKTDUh2y/23bXWkN4I2Rc5iuxJypwDFFMs= github.com/luxfi/pq v1.0.3/go.mod h1:8bppZcRElfrVt0n3nYCZW3iX1TvhvzNbdjNdK1irgIE= github.com/luxfi/sampler v1.0.0 h1:k8Sf6otW83w4pQp0jXLA+g3J/joB7w7SqXQsWmNTOV0= github.com/luxfi/sampler v1.0.0/go.mod h1:f96/ozlj9vFfZj+akLtrHn4VpulQahwB+MQQhpeIekk= github.com/luxfi/utils v1.1.4 h1:8OY0jXCkpp6OotN1Y++6DATJkvtEwzq2k0p56imJlAk= github.com/luxfiE/utils v1.1.4/go.mod h1:c3yz1RjzrB+cs5GZm+q1T3/2cCKElO9vxm9yRRtgSEM= 0h1:wiOXfctxiNk0EAiaEPURTXemvO8fyaGViIkoQVWs7Kw= 8/go.mod h1:WOBoeqEh0BCApg1wfxoadOLMXZUC9T1ksOABGoEp8os= 0h1:1lLHEmkyC0BucnA/zjQYsMkUVxuEo2vQkEaQGjYfuuc= 8/go.mod h1:Qukh3hDRD0MnxA6z+a28JTnXhN85AiLLgp6TYr4QAMc= 4-0h1:2e8XJozaERVxGwsRg72coi51L2aiYqE2gukkdLc85ck= 4,8/go.mod h1:CBAUADJuMNhJpyM6IYaWAoFhtKaqnUcznY2cL7gNugY= 0h1:+u9SLTRGnXv73cEsnsmoZBom+dMU88B2M0aDcWy0/jY= Icolorable v0.1.15/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= #0h1:j8l17JJ9i6VGPUFUYoTUKPSgKe/83EYU2zBC7YNKMw4= "8/go.mod h1:ZXfXG4SQHsB/w3ZeOYbR0PrPwLy+n6xiMrJlRFqopa4=  >1.14.8/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= 1 h1:gXHsfypPkaMZrKbD5209QV9jbUTJKjyR5WD3HYQSd+U= 8/go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= :27/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNgztCETuNZ7xM= 0h1:vhmr+TF2A3tuoGNkLDFK9zi36F2LS+hKTRW0Uf8kbzI= 8/go.mod h1:+EuEPhdHOsfk6Wk5TT2CzssZdqkmFhf8r+aVyDEToIs= "0h1:8dwx/Pz49suywbO+auHCBpCtlW1OfpcLN7wYgVR6wAI= !8/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg= *!0h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSQbirFg34= * 8/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM= X$0h1:RCJM0R1XOsRs+A3x3UCaf3ZYbByDaLjFeAi+YCQEPhs= X#8/go.mod h1:EU9hENAStx/xXduNdrGO5e4X5vk19NtgB+RIPjZO8o0= !0h1:K6Y13R2h+dku0wOqKtecgRnBUBPrZzLZy5aIj8lCcJI=  8/go.mod h1:2BuubE67DCSWwVfx37JWNG8emOC0sHEU4/HpcYgCLX8= @0h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= ?/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/nats-io/nats.go v1.44.0 h1:ECKVrDLdh/kDPV1g0gAQ+2+m2KprqZK5O/eJAyAnH2M= github.com/nats-io/nats.go v1.44.0/go.mod h1:iRWIPokVIFbVijxuMQq4y9ttaBTMe0SFdlZfMDd+33g= github.com/nats-io/nkeys v0.4.11 h1:q44qGV008kYd9W1b1nEBkNzvnWxtRSQ7A8BoqRrcfa0= github.com/nats-io/nkeys v0.4.11/go.mod h1:szDimtgmfOi9n25JpfIdGw12tZFYXqhGxjhVxsatHVE= github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw= github.com/nats-io/nuid v1.0.1/7go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= &0h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w= %8/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls= 7 0h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM= 7/go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/sftp v1.13.6 h1:JFZT4XbOU7l77xGSpOdW+pwIMqP044IyjXX6FGyEKFo= github.com/pkg/sftp v1.13.6/go.mod h1:tz1ryNURKu77RL+GuCzmoJYxQczL3wLNNpPWagdg4Qk= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhY#xTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= ?golang v1.23.2 h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= Fgolang v1.23.2/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg= *0h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk= )8/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= 0h1:8rQJvQmYltsR2L7h8Zw0Iyj8WYNNmpwikoQTZXwfVeA=  8/go.mod h1:4soH+U8yJSROk7OJ//hmTiWKsxapv6zRGgTt3keN8gQ= %0h1:XwbrGOIplXW/AU3YhIhLODXMJYyC1isLFfYCsTEycfc= $8/go.mod h1:o9EMBZGRyvDrSPH1RqdxhojkuXstoe4UlK79eF5TGGo= 8B0h1:9bBMbcwroL46feESdJWjRX0GV+k8o/P9gAg9UX6Vz7U= 8A8/go.mod h1:iW4cSew5PAb1sMZiTEkVJAIBNrepaB6jTYjeP47WtI0= D0h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= C/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/rs/xid v1.6.0 h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= github.com/rs/xid v1.6.0/go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= github.com/studio-b12/gowebdav v0.11.0 h1:qbQzq4USxY28ZYsGJUfO5jR+xkFtcnwWgitp4Zp1irU`= github.com/studio-b12/gowebdav v0.11.0/go.mod h1:bHA7t77X/QFExdeAnDzK6vKM34kEZAcE1OX4MfiwjkE= &0h1:DuWcpNu/FzgEXgGBDp8J1Spc+CWOvvtvVyjKlaZopYU= %8/go.mod h1:LvKtzl2RqO4gyF27BiXU+nKAjcV8f38U+kP/q2vgxh0= 10h1:mOwYbyYDLPj35mkA2BjjYejgJk9BuHxDdvRnb6v2ZcQ= 18/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA= ]#0h1:9j4uCAJyO3IJHygeOdUJNzm6sX3P1+3xuKTbCITQrvc= ]"8/go.mod h1:cDOlK/pNYGbGKRNa+NnXDJ1c8R63tWjnTjFKzoSbLv0= F0h1:gQ+ZV4wJke/EBKYciZ2MshEouEHFuinB85dY3f5s1q8= E/go.mod h1:jMeV4Vpbi8osrE/pKUxRZkVaA0EX7NZN0A9/oRzgpgY= github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUo^NXj+IQ= github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0= 0h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs= /go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s= go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0R= go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= $0h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= #/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.46.1 h1:SpGay3w+nEwMpfVnbqOLH5gY52/foP8RE8UzTZ1pdSE= go.opentelemetry.io/contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.46.1/go.mod h1:4UoMYEZOC0yN/sPGH76KPkkU7zgiEWYWL9vwmbnTJPE= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v0.46.1 h1:aFJWCqJMNjENlcleuuOkGAPH82y0yULBScfXcIEdS24= go.opentelemetry.io/contrib/instrumentation/net/http/otelhttp v>0.46.1/go.mod h1:sEGXWArGqc3tVa+ekntsN65DmVbVeW+7lTKTjZF3/Fo= 9 v1.44.0 h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= @ v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= ?metric v1.44.0 h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= Fmetric v1.44.0/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= '0h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= &/go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdMYcacYXQ= go.yaml.in/yaml/v3 v3.0.4 h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= go.yaml.in/yaml/v3 v3.0.4/go.mod h1:DhzuOOF2%ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= W0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= W0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= 0h1:RMs7fP2rXdep0CftQlK8Uf+kibLm7qkCcradZWYz988= 8/go.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc= G40h1:4d4PbuBNwaxMXkXI8yiIYjydtMU+04RHeuSxJdgKftM= G3/go.mod h1:d2fgXJLVs4dYDHUk5lwMIfzRzSrWCfGZb0ZqeLa/Vcw= golang.org/x/mod v0.1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= golang.org/x/mod v0.36.0 h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4= golang.org/x/mod v0.36.0/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net 0h1:bcvxaJn3e1U6InsFWt1JUq1aSjnRxLzT2rtD2KfkDF8= /go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= golang.org/x/sync v0.20.0 h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4= golang.org/x/sync v0.20.0/go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9%XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY= golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= !:.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= !0h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc= !/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= golang.org/x/tools v0.0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= golang.org/x/tools v0.45.0 h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8= golang.org/x/tools v0.45.0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= google.golang.org/api v0.154.0 h1:X7QkVKZBskztmpPKWQXgjJRPA2dJYrL6r+sYPRLj050= google.golang.org/api v0.154.0/go.mod h1:qhSMkM85hgqiokIYsrRyKxrjfBeIhgl4Z2JmeRkYylc= google.golang.org/genproto v0.0.0-20231212172506-995d672761c0 h1:YJ5pD9rF8o9Qtta0Cmy9rdBwkSjrTCT6XTiUQVOtIos= google.golang.org/genproto v0.0.0-20231212172506-995d672761c0/go.mod h1:l/k7rMz0vFTBPy+tFSGvXEd3z+BcoG1k7EHbqm+YBsY= google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9 h1:VPWxll4HlMw1Vs/qXtN7BvhZqsS9cdAittCNvVENElA= google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9/go.mod h1:7QBABkRtR8z+TEnmXTqIqwJLlzrZKVfAUm7tY3yGv0M= google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9 h1:m8qni9SQFH0tJc1X0vmnpw/0t+AImlSvp30sEupozUg= google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.80.0 h1:Xr6m2WmWZLETvUNvIUmeD5OAagMw3FiKmMlTdViWsHM= google.golang.org/grpc v1.80.0/go.mod h1:ho/dLnxwi3EDJA4Zghp7k2Ec1+c2jqup0bFkw07bwF4= p$0h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= p#/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in0h1:JtOSMb9OuaCZKr7h5D/h6iii14sK0hLbplTc6frx4Ss= 8/go.mod h1:x/cyOwCgZqOkJoDIJ3c1KNHMo10+nLGAhh+kn3Zizss= (0h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= '/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= modernc.org/cc/v4 v4.28.2 h1:3tQ0lf2ADtoby2EtSP+J7IE2SHwEJdP8ioR59wx7XpY= modernc.org/cc/v4 v4.28.2/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= modernc.org/ccgo/v4 v4.34.2 h1:mxsy2FdrB6+qG3NfXefz1AmWv0ehOSDO4jxgxd7h9yo= modernc.org/ccgo/v4 v4.34.2/go.mod h1:1L7us56+kAKu04p25EATpmBBvhbcqqZ85ibqWVwVgog= modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM= modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU= modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI= modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito= modernc.org/gc/v3 v3.1.3 h1:6QAplYyVO+KdPW3pGnqmJDUxtkec8ooEWvks/hhU3lc= modernc.org/gc/v3 v3.1.3/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEiMai46V+i7Jrj13t4AzuNks= modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= h1:m2OGx9Ser1VvTS4Z9ZJlWs+CBMxutLaTiAWkNz+NB9U= modernc.org/libc v1.72.5/go.mod h1:np0N7KDJ7eUtMZmOqVZNldrZyG+DHLl2B5pg8Hbar3U= !0h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= !8/go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= J0h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI= J/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw= modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg= modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMjDzETGsSMqJE= modernc.org/sqlite v1.51.0 h1:aH/MMSoayAIhozZ7uJbVTT9QO/VhzBf0J9tymmmuC/U= modernc.org/sqlite v1.51.0/go.mod h1:tcNzv5p84E0skkmJn038y+hWJbLQXQqEnQfeh5r2JLM= modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= modernc.orgE/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= e xUJ@9]e#Vc!*mD Xv$mvqV J +kRZY.3f?:Gfo9\_eu}Yփ`ew<C8s$c)'e, T3,hWR cu$ CZ1ΰ c H7K(li wvbLI wV.5HJ\{ mi%kgܐ|U2-܄/8{b5QdABynĄ�&x;ڬ$RM")100644 go.sum�7s aqpl%7Rx+�"40000 .github�uw :>>7))"7u9xC�"40000 .github�f}1W /Kha*"]Spv9c[%(]'Z x�##3A/x{?#c2sp.org/CCTV/age v0.0.0-20251208015420-e9274a7bdbfd h1:ZLsPO6WdZ5zatV4UfVpr7oAwLGRZ+sebTUruuM4Ra3M= c2sp.org/CCTV/age v0.0.0-20251208015420-e9274a7bdbfd/go.mod h1:SrHC2C7r5GkDk8R+NFVzYy/sdj0Ypg9htaPXQq5Cqeo= cloud.google.com/go v0.111.0 h1:YHLKNupSD1KqjDbQ3+LVdQ81h/UJbJyZG203cEfnQgM= cloud.google.com/go v0.111.0/go.mod h1:0mibmpKP1TyOOFYQY5izo0LnT+ecvOQ0Sg3OdmMiNRU= cloud.google.com/go/compute/metadata v0.9.0 h1:pDUj4QMoPejqq20dK0Pg2N4yG9zIkYGdBtwLoEkH9Zs= cloud.google.com/go/compute/metadata v0.9.0/go.mod h1:E0bWwX5wTnLPedCKqk3pJmVgCBSM6qQI1yTBdEb3C10= cloud.google.com/go/iam v1.1.5 h1:1jTsCu4bcsNsE4iiqNT5SHwrDRCfRmIaaaVFhRveTJI= cloud.google.com/go/iam v1.1.5/go.mod h1:rB6P/Ic3mykPbFio+vo7403drjlgvoWfYpJhMXEbzv8= cloud.google.com/go/storage v1.36.0 h1:P0mOkAcaJxhCTvAkMhxMfrTKiNcub4YmmPBtlhAyTr8= cloud.google.com/go/storage v1.36.0/go.mod h1:M6M/3V/D3KpzMTJyPOR/HU6n2Si5QdaXY Esng2xgOs8= 00h1:p575VVQ6ted4pL+it6M00V/f2qTZITO0zgmdKCkd5+A= 0/go.mod h1:EmAN849/P3qdeK+PCMkDpDm83vRHM5cDipBJ8xbQLVY= github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.2 h1:Hr5FTipp7SL07o2FvoVOX9HRiRH3CR3Mj8pxqCcdD5A= github.com/Azure/azure-sdk-for-go/sdk/azcore v1.18.2/go.mod h1:QyVsSSN64v5TGltphKLQ2sQxe4OBQg0J1eKRcVBnfgE= github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.11.0 h1:MhRfI58HblXzCtWEZCO0feHs8LweePB3s90r7WaR1KU= github.com/Azure/azure-sdk-for-go/sdk/azidentity v1.11.0/go.mod h1:okZ+ZURbArNdlJ+ptXoyHNuOETzOl1Oww19rm8I2WLA= github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2 h1:9iefClla7iYpfYWdzPCRDozdmndjTm8DXdpCzPajMgA= github.com/Azure/azure-sdk-for-go/sdk/internal v1.11.2/go.mod h1:XtLgD3ZD34DAaVIIAyG3objl5DynM3CQ/vMcbBNJZGI= github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.2 h1:FwladfywkNirM+FZYLBR2kBz5C8Tg0fw5w5Y7meRXWI= github.com/Azure/azure-sdk-for-go/sdk/storage/azblob v1.6.2/go.mod h1:vv5Ad0RrIoT1lJFdWBZwt4mB1+j+V8DUroixmKDTCdk= github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2 h1:oygO0locgZJe7PpYPXT5A29ZkwJaPqcva7BVeemZOZs= github.com/AzureAD/microsoft-authentication-library-for-go v1.4.2/go.mod h1:wP83P5OoQ5p6ip3ScPr0BAq0BvuPAvacpEuSzyouqAI= github.com/aliyun/alibabacloud-oss-go-sdk-v2 v1.3.0 h1:wQlqotpyjYPjJz+Noh5bRu7Snmydk8SKC5Z6u1CR20Y= github.com/aliyun/alibabacloud-oss-go-sdk-v2 v1.3.0/go.mod h1:FTzydeQVmR24FI0D6XWUOMKckjXehM/jgMn1xC+DA9M= github.com/aws/aws-sdk-go-v2 v1.41.0 h1:tNvqh1s+v0vFYdA1xq0aOJH+Y5cRyZ5upu6roPgPKd4= github.com/aws/aws-sdk-go-v2 v1.41.0/go.mod h1:MayyLB8y+buD9hZqkCW3kX1AKq07Y5pXxtgB+rRFhz0= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.4 h1:489krEF9xIGkOaaX3CE/Be2uWjiXrkCH6gUX+bZA/BU= github.com/aws/aws-sdk-go-v2/aws/protocol/eventstream v1.7.4/go.mod h1:IOAPF6oT9KCsceNTvvYMNHy0+kMF8akOjeDvPENWxp4= github.com/aws/aws-sdk-go-v2/config v1.32.6 h1:hFLBGUKjmLAekvi1evLi5hVvFQtSo3GYwi+Bx4lpJf8= github.com/aws/aws-sdk-go-v2/config v1.32.6/go.mod h1:lcUL/gcd8WyjCrMnxez5OXkO3/rwcNmvfno62tnXNcI= github.com/aws/aws-sdk-go-v2/credentials v1.19.6 h1:F9vWao2TwjV2MyiyVS+duza0NIRtAslgLUM0vTA1ZaE= github.com/aws/aws-sdk-go-v2/credentials v1.19.6/go.mod h1:SgHzKjEVsdQr6Opor0ihgWtkWdfRAIwxYzSJ8O85VHY= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.16 h1:80+uETIWS1BqjnN9uJ0dBUaETh+P1XwFy5vwHwK5r9k= github.com/aws/aws-sdk-go-v2/feature/ec2/imds v1.18.16/go.mod h1:wOOsYuxYuB/7FlnVtzeBYRcjSRtQpAW0hCP7tIULMwo= github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.20.18 h1:9vWXHtaepwoAl/UuKzxwgOoJDXPCC3hvgNMfcmdS2Tk= github.com/aws/aws-sdk-go-v2/feature/s3/manager v1.20.18/go.mod h1:sKuUZ+MwUTuJbYvZ8pK0x10LvgcJK3Y4rmh63YBekwk= github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.16 h1:rgGwPzb82iBYSvHMHXc8h9mRoOUBZIGFgKb9qniaZZc= github.com/aws/aws-sdk-go-v2/internal/configsources v1.4.16/go.mod h1:L/UxsGeKpGoIj6DxfhOWHWQ/kGKcd4I1VncE4++IyKA= github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.16 h1:1jtGzuV7c82xnqOVfx2F0xmJcOw5374L7N6juGW6x6U= github.com/aws/aws-sdk-go-v2/internal/endpoints/v2 v2.7.16/go.mod h1:M2E5OQf+XLe+SZGmmpaI2yy+J326aFf6/+54PoxSANc= github.com/aws/aws-sdk-go-v2/internal/ini v1.8.4 h1:WKuaxf++XKWlHWu9ECbMlha8WOEGm0OUEZqm4K/Gcfk= github.com/aws/aws-sdk-go-v2/internal/ini v1.8.4/go.mod h1:ZWy7j6v1vWGmPReu0iSGvRiise4YI5SkR3OHKTZ6Wuc= github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.16 h1:CjMzUs78RDDv4ROu3JnJn/Ig1r6ZD7/T2DXLLRpejic= github.com/aws/aws-sdk-go-v2/internal/v4a v1.4.16/go.mod h1:uVW4OLBqbJXSHJYA9svT9BluSvvwbzLQ2Crf6UPzR3c= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.4 h1:0ryTNEdJbzUCEWkVXEXoqlXV72J5keC1GvILMOuD00E= github.com/aws/aws-sdk-go-v2/service/internal/accept-encoding v1.13.4/go.mod h1:HQ4qwNZh32C3CBeO6iJLQlgtMzqeG17ziAA/3KDJFow= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.7 h1:DIBqIrJ7hv+e4CmIk2z3pyKT+3B6qVMgRsawHiR3qso= github.com/aws/aws-sdk-go-v2/service/internal/checksum v1.9.7/go.mod h1:vLm00xmBke75UmpNvOcZQ/Q30ZFjbczeLFqGx5urmGo= github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.16 h1:oHjJHeUy0ImIV0bsrX0X91GkV5nJAyv1l1CC9lnO0TI= github.com/aws/aws-sdk-go-v2/service/internal/presigned-url v1.13.16/go.mod h1:iRSNGgOYmiYwSCXxXaKb9HfOEj40+oTKn8pTxMlYkRM= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.16 h1:NSbvS17MlI2lurYgXnCOLvCFX38sBW4eiVER7+kkgsU= github.com/aws/aws-sdk-go-v2/service/internal/s3shared v1.19.16/go.mod h1:SwT8Tmqd4sA6G1qaGdzWCJN99bUmPGHfRwwq3G5Qb+A= github.com/aws/aws-sdk-go-v2/service/s3 v1.95.0 h1:MIWra+MSq53CFaXXAywB2qg9YvVZifkk6vEGl/1Qor0= github.com/aws/aws-sdk-go-v2/service/s3 v1.95.0/go.mod h1:79S2BdqCJpScXZA2y+cpZuocWsjGjJINyXnOsf5DTz8= github.com/aws/aws-sdk-go-v2/service/signin v1.0.4 h1:HpI7aMmJ+mm1wkSHIA2t5EaFFv5EFYXePW30p1EIrbQ= github.com/aws/aws-sdk-go-v2/service/signin v1.0.4/go.mod h1:C5RdGMYGlfM0gYq/tifqgn4EbyX99V15P2V3R+VHbQU= github.com/aws/aws-sdk-go-v2/service/sso v1.30.8 h1:aM/Q24rIlS3bRAhTyFurowU8A0SMyGDtEOY/l/s/1Uw= github.com/aws/aws-sdk-go-v2/service/sso v1.30.8/go.mod h1:+fWt2UHSb4kS7Pu8y+BMBvJF0EWx+4H0hzNwtDNRTrg= github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.12 h1:AHDr0DaHIAo8c9t1emrzAlVDFp+iMMKnPdYy6XO4MCE= github.com/aws/aws-sdk-go-v2/service/ssooidc v1.35.12/go.mod h1:GQ73XawFFiWxyWXMHWfhiomvP3tXtdNar/fi8z18sx0= github.com/aws/aws-sdk-go-v2/service/sts v1.41.5 h1:SciGFVNZ4mHdm7gpD1dgZYnCuVdX1s+lFTg4+4DOy70= github.com/aws/aws-sdk-go-v2/service/sts v1.41.5/go.mod h1:iW40X4QBmUxdP+fZNOpfmkdMZqsovezbAeO+Ubiv2pk= github.com/aws/smithy-go v1.24.0 h1:LpilSUItNPFr1eY85RYgTIg5eIEPtvFbskaFcmmIUnk= github.com/aws/smithy-go v1.24.0/go.mod h1:LEj2LM3rBRQJxPZTB4KuzZkaZYnZPnvgIhb4pu07mx0= github.com/beorn7/perks v1.0.1 h1:VlbKKnNfV8bJzeqoa4cOKqO6bYr3WgKZxO8Z16+hsOM= github.com/beorn7/perks v1.0.1/go.mod h1:G2ZrVWU2WbWT9wwq4/hrbKbnv/1ERSJQ0ib hJ6rlkpw= 00h1:tNowT99t7UNflLxfYYSlKYsBpXdEet03Pg2g16Swow4= /8/go.mod h1:90ReRw6GdpyfrHakVjL/QHaoyV4aDUVVkXQJJJ3NXXM= $0h1:UL815xU9SqsFlibzuggzjXhog7bL6oX9BbNZnL2UFvs= #8/go.mod h1:VGX0DQ3Q6kWi7AoAeZDth3/j3BFtOZR5XLFGgcrjCOs= #0h1:9GPOhQGF9MCYUeXyMYlqTR6a5gTrgR/fBLXvUgtVcg8= "/go.mod h1:2eXP6Qfat4O/Yhh8BznvKnJ+uzEoTQ6jVKJRn81BiS4= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc h1:U9qPSI2PIWSS1VwoXQT9A3Wy9MM3WgvqSxFWenqJduM= github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.1 h1:5RVFMOWjMyRy8cARdy79nAmgYw3hK/4HUq48LQ6Wwqo= github.com/decred/dcrd/dcrec/secp256k1/v4 v4.4.1/go.mod h1:ZXNYxsqcloTdSy/rNShjYzMhyjf0LaoftYK0p+A3h40= )0h1:I/w09yLjhdcVD2QV192UJcq8dPBaAJb9pOuMyNy0XlU= (/go.mod h1:0KsrXtXvnv0EqnzyowllbVJB8yBonswa2lTCK2gGo9E= github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da h1:aIftn67I1fkbMa512G+w+Pxci9hJPB8oMnkcP3iZF38= github.com/dgryski/go-farm v0.0.0-20240924180020-3414d57e47da/go.mod h1:SqUrOPUnsFjfmXRMNPybcSiG0BgUW2AuFH8PAnS2iTw= T%0h1:GzkhY7T5VNhEkwH0PVJgjz+fX1rhBrR7pRT3mDkpeCY= T$/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= github.com/felixge/httpsnoop v1.0.4 h1:NFTV2Zj1bL4mc9sqWACXbQFVBBg2W3GPvqp8/ESS2Wg= github.com/felixge/httpsnoop v1.0.4/go.mod h1:m8KPJKqk1gH5J9DgRY2ASl2lWCfGKXixSwevea8zH2U= github.com/go-chi/chi/v 0h1:halUjDxhshgXHMrao5bB8eNBXo/rnzwr8m5m36glehM= /go.mod h1:R+tYY2hNuVUUjxoPtqUdgBqevM9s9njzkTLutVsOCto= github.com/go-logr/logr v1.2.2/go.mod h1:jdQByPbusPIv2/zmleS9BjJVeZ6kBagPoEUsqbVz/1A= github.com/go-logr/logr v1.4.3 h1:CjnDlHq8ikf6E492q6eKboGOC0T8CDaOvkHCIg8idEI= github.com/go-logr/logr v1.4.3/go5.mod h1:9T104GzyrTigFIr8wt5mBrctHMim0Nb2HLGrmQ40KvY= 0h1:hSWxHoqTgW2S2qGc0LTAI563KZ5YKYRhT3MFKZMbjag= /go.mod h1:mMo/vtBO5dYbehREoey6XUKy/eSumjCCveDpRre4VKE= github.com/golang-jwt/jwt/v5 v5.3.1 h1:kYf81DTWFe7t+1VvL7eS+jKFVWaUnK9cB1qbwn63YCY= github.com/golang-jwt/jwt/v5 v5.3.1/go.mod h1:fxCRLWMO43lRc8nhHWY6LGqRcf+1gQWArsqaEUEa5bE= github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da h1:oI5xCqsCo564l8iNU+DwB5epxmsaqB+rhGL0m5jtYqE= github.com/golang/groupcache v0.0.0-20210331224755-41bb18bfe9da/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc= github.com/golang/protobuf v1.5.3 h1:KhyjKVUg7Usr/dYsdSqoFveMYd5ko72D+zANwlG1mmg= github.com/golang/protobuf v1.5.3/go.mod h1:XVQd3VNwM+JqD3oG2Ue2ip4fOMUkwXdXDdiuN0vRsmY= gi 30h1:haMV2JRRJCe1998HeW/p0X9UaMTK6SDo0ffLn2+DbLs= 4/go.mod h1:1AeVuKshWv4vARoZatz6mlQ0JxURH0Kv5+zNeJKJCa8= github.com/google/go-cmp v0.5.6/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= github.com/google/go-cmp v0.7.0 h1:wk8382ETsv4JYUZwIsn6YpYiWiBsYLSJiTsyBybVuN8= github.com/google/go-cmp v0.7.0/go.mod h1:pXiqmnSA92OHEEa9HXL2W4E7lf9JzCmGVUdgjX3N/iU= github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc h1:VBbFa1lDYWEeV5FZKUiYKYT0VxCp9twUmmaq9eb8sXw= github.com/google/pprof v0.0.0-20260302011040-a15ffb7f9dcc/go.mod h1:MxpfABSjhmINe3F1It9d+8exIHFvUqtLIRCdOGNXqiI= github.com/google/s2a-go v0.1.7 h1:60BLSyTrOV4/haCDW4zb1guZItoSq8foHCXrAnjBo/o= github.com/google/s2a-go? v0.1.7/go.mod h1:50CgR4k1jNlWBu4UfS4AcfhVe1r6pdZPygJ3R8F0Qdw= M0h1:NIvaJDMOsjHA8n1jAhLSgzrAzy1Hgr+hNrb57e+94F0= M/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo= github.com/googleapis/enterprise-certificate-proxy v0.3.2 h1:Vie5ybvEvT75RniqhfFxPRy3Bf7vr3h0cechB90XaQs= github.com/googleapis/enterprise-certificate-proxy v0.3.2/go.mod h1:VLSiSSBs/ksPL8kq3OBOQ6WRI2QnaFynd1DCjZ62+V0= github.com/googleapis/gax-go/v2 v2.12.0 h1:A+gCJKdRfqXkr+BIRGtZLibNXf0m1f9E4HG56etFpas= github.com/googleaMpis/gax-go/v2 v2.12.0/go.mod h1:y+aIqrI5eb1YGMVJfuV3185Ts/D7qKpsEkdD5+I6QGU= x0h1:TuBL49tXwgrFYWhqrNgrUNEY92u81SPhu7sTdzQEiWY= x/go.mod h1:AKf9I4AEqPTmMytcMc0KkNouC66V3BtZ4qD5fmWSiMQ= github.com/gorilla/rpc v1.2.1 h1:yC+LMV5esttgpVvNORL/xX4jvTTEUE30UZhZ5J\F7K9k= github.com/gorilla/rpc v1.2.1/go.mod h1:uNpOihAlF5xRFLuTYhfR0yfCTm0WTQSQttkMSptRfGk= 8A1 h1:JeSE6pjso5THxAzdVpqr6/geYxZytqFMBCOtn/ujyeo= 8A8/go.mod h1:r4w70xmWCQKmi1ONH4KIaBptdivuRPyosB9RmPlGEwA= $0h1:uHhahLBKqwWBV6WZUDAT71044vwOTL+McW0mBJvo6kE= #8/go.mod h1:lTKmG1zh86XyCoUeIHSA4FJMBwCJiQmGfcP2PdzytEs= 1 0h1:drT/MZpSZJQXo7jftf5fthArShcaMtsal0Zf/dnmp6k= 1Dhijri v1.0.2/go.mod h1:OS5qyYLDjORXzK4O1adFw9Q5WfhOcMdAKglDkcTxgWQ= 1*0h1:A8YM7wIj16SzlKT0SRJc9CD29iiaUzpBLzh5hr0/5p0= 1)8/go.mod h1:0JOYq4oFOuDja+oospuc61YoX+uNEn7Z6uHYTbBzdGc= h0h1:jWamJSHg1RtvcarevSJ/W5lyPJfRB4vBYXDuxyyOup0= h8/go.mod h1:rWgoDyQiB5d+GOGYncKrQu6uS7Gnoh0xlm1hCU5rq5E= "0h1:NjK1Umwaxb5lnoFB44iGPtGj58y/PLucNcCc2gE8q4I= !8/go.mod h1:/iX6TGHL94Q9MkMmvHKKHlyopHn06RjEW7Bz3h6TJEk= $0h1:PulFMIVVbvxz/LmBSKlj/o+T7nZmPGd2L2YjYVv5V1U= #8/go.mod h1:U0WdEoFFNw4lS9CRysXtsWOqtkzjIi2Ggv+C8Nsz8+4= *0h1:a+bsQ5rvGLjzHuww6tVxozPZFVghXaHOwFs4luLUK2k= )/go.mod h1:QeFd9opnmA6QUJc5vARoKUSoFhyfM2/ZepoAG6RGpeM= github.com/holiman/uint256 v1.3.2 h1:a9EgMPSC1AAaj1SZL5zIQD3WbwTuHrMGOedrLjGmM/TA= github.com/holiman/uint256 v1.3.2/go.mod h1:EOMSn4q6Nyt9P6efbI3bueV4e1b3dGlUCXeiRV4ng7E= *A0h1:lvIuaX7hO0eO3Rlev+cVnlsoExR3i/JXxu88zt4JHPg= *@8/go.mod h1:Wqfu7mjUHj9WDzSSPI5KfBclTTEnLveRUFr/ujWnTgE= x&0h1:2jupLlAwFm95+YDR+NwD2MEfFO9d4z4Prjl1XXDjuao= x%8/go.mod h1:cwPg85FWrGar70rWktvGQj8/hthj3wpl0PGDogxkrSQ= !;0.1/go.mod h1:FInQzS24/EEf25PyTYn52gqo7WaD8xa0213Md/qVLRg= %0h1:S4CRMLnYUhGeDFDqkGriYKdfoFlDnMtqTiI/sFzhA9Y= $8/go.mod h1:hqwkgyIinND0mEev00jJYCxPNVRVXFQeu1XKlok6oO0= "0h1:sSmTt3gUt81RP655XGZPElI0PelVTZ6YwCRnPSupoFM= !/go.mod h1:D7kQaZhnkX/Y0tstFGf8VUzv2UofNGqCjnC3zdHB0Hw= github.com/kr/fs v0.1.0 h1:Jskdu9ieNAYnjxsi0LbQp1ulIKZV1LAFgK1tWhpZgl8= github.com/kr/fs v0.1.0/go.mod h1:FFnZGqtBN9Gxj7eW1uZ42v5BccTP0vu6NEaFoC2HwRg= github.com/kr/pretty v0.3.1 h1:flRD4NNwYAUpkphVc1HcthR4KEIFJ65n8Mw5qdRn3LE= github.com/kr/pretty v0.3.1/go.mod h1:hoEshYVHaxMs3cyo3Yncou5ZscifuDolrwPKZanG3xk= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= github.com/kr/text v0.2.0/go.mod h1:eLer722TekiGuMkidMxC/pM04lWEeraHUUmBw8l2grE= github.com/kylelemons/godebug v1.1.0 h1:RPNrshWIDI6G2gRW9EHilWtl7Z6Sb1BR0xunSBf0SNc= github.com/kylelemons/godebug? v1.1.0/go.mod h1:9/0rRGxNHcop5bhtWyNeEfOS8JIWk580+fNqagV/RAw= 0h1:tTWxr2YLKwIvK90ZXEw8GP7UFHtcbTtty8zsI+YjrfQ= 8/go.mod h1:/p+8NSbOcwzAEI7wiMXFlgydTwcgTr3OSKMsD2BitpA= 3!h1:Hv4EaHWXQr+GTFnOU4VKf8UvAtZgn0VuKT+G0wFlO3I= github.com/lmittmann/tint v1.1.3/go.mod h1:HIS3gSy7qNwGCj+5oRjAutErFBl4BzdQP6cJ Z0NfMwE= a0h1:Tsk6gXj2uKE19501bD0ajRYdeCHIlTGb6jYyLc+F8hc= a8/go.mod h1:K00BcnLzEYMPHwCFq8Tf/450ApmTs9xBVvYOnofJCkc= 0h1:G69HbSV4R3vKEH9B0CulnRaMdSdf4RalMgP8xKmxHeI= /go.mod h1:iAYAxgvrXxcy746+Ovh/eWWDuF9teJLNcCSSOX9RYW0= github.com/luxfi/atomic v1.0.0 h1:xUV60MuzRvXngaQ1sM0yVC2v4TRoLlUGkkH7M9PS4yw= github.com/luxfi/atomic v1.0.0/go.mod h1:0G2mTlQ6TXWHICUHrUUPu1/qAiIyR4gSZ2tva9ci/bI= github.com/luxfi/cache v1.2.1 h1:kAzOS55/hmYeNKR+0HAKv4ma48Y6JjkI8UQeqdZ8bfI= github.com/luxfi/cache v1.2.1/go.mod h1:co7JTxZZHpKT31Yh01LFp5aZOxmoUg157FhBLQdQHVU= 0h1:Yl8ZalMNkqo7cD6R9AjczAajkLOmsjyZ9+DASVYHrvg= 8/go.mod h1:oGQ3j6E8c2P0pL0irYtWkrB1hmDUFIE0puXHK4gV5KI= !0h1:4tEUHw5MK1bu5UOjfYCt4OKMiH7yykIgmGPRA/BfJTM=  8/go.mod h1:Cc1yxD2pfzrvpO32W2GDwLKff+CylHEvzZh2Ko8RSIU= 9#0h1:eJyv1fhaC0jMLMw6+QS774cUmp7GK+ouMgvLCqnC7cc= 9"/go.mod h1:Aj/FR5NpM0cB2P4Nt3+tz9+dV6V+LUW4HuMgSjwq5hw= github.com/luxfi/constants v1.4.7 h1:e/Qs+DQP3pugle3Zncq6fZCxKgqqtbyD/z7Gm4ZjsYg= github.com/luxfi/constants v1.4.7/go.mod h1:hOszZ2NDQ8gMZKncfcZ67PXkb5OIbnwAzXC3oFbQwW0= github.com/luxfi/container v0.0.4 h1:BXhF82WyfqVP5mjlNcr7tP0Fcnvl0Ap1rkiu+rq5XuM= github.com/luxfi/container v0.0.4/go.mod h1:Z3SpmMF5d4t77MM0nHYXURpn+EMVaeu1fhbd/3BGaek= i!0h1:l2LLu7UFyICtJVfraLDLRi+lFGiDXKHSL18M9/m1gsQ= i 8/go.mod h1:INjdZtke85k8hX/QAmTMAY8bbZ4gzGZQLqURg3xf6Gk= "0h1:sySH5eS8ihJtyc+yb0LgTignGwJ9H4W9bv+nboCuIm0= !/go.mod h1:o1ccjgVKMYbVBfi+6+sDvx4swGFgGnCGFQ4gL/oJ+kY= github.com/luxfi/geth v1.16.98 h1:w187TtKuGStf3tm2bshuHVKBv2Frjx0lT54kQ^VXyNHA= github.com/luxfi/geth v1.16.98/go.mod h1:6kEzSExdk9CPQDPXALt6P3HfQqBq7KF1Jrrv9gBpxbU= {1 h1:cgHiBU8vBO4b39HnVr1UewEAeP3Bx+JZBHlfacTvDZQ= {/go.mod h1:NbKTixz6Miunyh+7ER3G389mzUKV22QIVPjpcTnKZuY= github.com/luxfi/ids v1.2.13 h1:lEotq0WUpMLcc/5X5MbE3n73jdfNo8IlFvTDfUXZg+9A= github.com/luxfi/ids v1.2.13/go.mod h1:QWjJvggX/nRkmrz1AGSaF2Y6mnOvz3g7lFOzs3Zd+JM= 1 h1:vfYgM/hnNujjS47B7/VKAxFJHsFhhME0SnLaAAaYuwA= 8/go.mod h1:pz5W+DqKx0La2uyq1mV5Kpi0gXXNhmVpZTZRmhw+fX4= 0h1:xkUKRWvQ4ZwvlUC2e0/RTtHYZOYSMvSQ9W9lbjwBmiI= 8/go.mod h1:myIkufyiQomSQH34K981kbz6cG4WUoerRUh7F4XhlQI= 0h1:1t9bCCsEqnl9yIKrShlbs80DBKyYTWdnzkVfBqEeO7Q= 8/go.mod h1:QvbRxauQyE1w4lvbcLSe6c8yeJz2Zj1Bq1rayGgs2tA= C!h1:Vz4c0RsZVPdIKPsHPgAJChH/R3p15WHRUz7LkLf+NIQ= github.com/luxfi/math/big v0.1.0/go.mod h1:BuxSu22RbO93xBLk5Eam5nldFponoJ73xDFz 4uJ3Huk= 1 h1:g2eRr9AXcziPkkcd24M+Qu9ApEpoKKjfI79QSNqv0rQ= 8/go.mod h1:dbp5f3h3aE7CGzwbaWzBM9cwdcekhmSrWhQevgYhhNA= q0h1:axPwfq+erOlIue7IJp5g+hMcMtVhYHja9gJAaT3+KNA= q8/go.mod h1:fO2giazkg4NDtr72JM/QXJBYebplAMeWC1JoZyNDvKw= 0h1:0HEtIjg1J6CWz+IUyP6rsGqNWTcmxjFnSQIhaDuARwY= /go.mod h1:jo35akl3Vtd8LbzDts8VJ0jmSVycrd1/eBi6g6t5hKU= github.com/luxfi/pq v1.0.3 h1:pFlQm1+5FuKTDUh2y/23bXWkN4I2Rc5iuxJypwDFFMs= github.com/luxfi/pq v1.0.3/go.mod h1:8bppZcRElfrVt0n3nYCZW3iX1TvhvzNbdjNdK1irgIE= github.com/luxfi/sampler v1.0.0 h1:k8Sf6otW83w4pQp0jXLA+g3J/joB7w7SqXQsWmNTOV0= github.com/luxfi/sampler v1.0.0/go.mod h1:f96/ozlj9vFfZj+akLtrHn4VpulQahwB+MQQhpeIekk= github.com/luxfi/utils v1.1.4 h1:8OY0jXCkpp6OotN1Y++6DATJkvtEwzq2k0p56imJlAk= github.com/luxfi/utils v1.1.4/go.mod h1:c3yz1RjzrB#+cs5GZm+q1T3/2cCKElO9vxm9yRRtgSEM= 8 v0.7.0 h1:wiOXfctxiNk0EAiaEPURTXemvO8fyaGViIkoQVWs7Kw= ? v0.7.0/go.mod h1:WOBoeqEh0BCApg1wfxoadOLMXZUC9T1ksOABGoEp8os= 0h1:1lLHEmkyC0BucnA/zjQYsMkUVxuEo2vQkEaQGjYfuuc= 8/go.mod h1:Qukh3hDRD0MnxA6z+a28JTnXhN85AiLLgp6TYr4QAMc=  -0h1:2e8XJozaERVxGwsRg72coi51L2aiYqE2gukkdLc85ck=  ,8/go.mod h1:CBAUADJuMNhJpyM6IYaWAoFhtKaqnUcznY2cL7gNugY= V &0h1:+u9SLTRGnXv73cEsnsmoZBom+dMU88B2M0aDcWy0/jY= V %8/go.mod h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stgPZH1UqBm1s8= #0h1:j8l17JJ9i6VGPUFUYoTUKPSgKe/83EYU2zBC7YNKMw4= "8/go.mod h1:ZXfXG4SQHsB/w3ZeOYbR0PrPwLy+n6xiMrJlRFqopa4= >1.14.8/go.mod h1:NyWgC/yNuGj7Q9rpYnZvas74GogHl5/Z4A/KQRfk6bU= /1 h1:gXHsfypPkaMZrKbD5209QV9jbUTJKjyR5WD3HYQSd+U= //go.mod h1:FPy6KqzDD04eiIsT53CuJW3U88zkxoIYsOqkbpncsNc= github.com/miekg/dns v1.1.27/go.mod h1:KNUDUusw/aVsxyTYZM1oqvCicbwhgbNg ztCETuNZ7xM= 0h1:vhmr+TF2A3tuoGNkLDFK9zi36F2LS+hKTRW0Uf8kbzI= 8/go.mod h1:+EuEPhdHOsfk6Wk5TT2CzssZdqkmFhf8r+aVyDEToIs= "0h1:8dwx/Pz49suywbO+auHCBpCtlW1OfpcLN7wYgVR6wAI= !/go.mod h1:eVfm2fAzLlxMdUGc0EEBGSMmPwmXD5XiNRpnu9J3bvg= github.com/minio/md5-simd v1.1.2 h1:Gdi1DZK69+ZVMoNHRXJyNcxrMA4dSxoYHZSbQbirFg34= github.com/minio/md5-simd v1.1.2/go.mod h1:MzdKDxYpY2BT9XQFocsiZf/NKVtR7nkE4RoEpN+20RM= @ $0h1:RCJM0R1XOsRs+A3x3UCaf3ZYbByDaLjFeAi+YCQEPhs= @ #8/go.mod h1:EU9hENAStx/xXduNdrGO5e4X5vk19NtgB+RIPjZO8o0= q !0h1:K6Y13R2h+dku0wOqKtecgRnBUBPrZzLZy5aIj8lCcJI= q 8/go.mod h1:2BuubE67DCSWwVfx37JWNG8emOC0sHEU4/HpcYgCLX8= @0h1:C3w9PqII01/Oq1c1nUAm88MOHcQC9l5mIlSMApZMrHA= ?/go.mod h1:+n7T8mK8HuQTcFwEeznm/DIxMOiR9yIdICNftLE1DvQ= github.com/nats-io/nats.go v1.44.0 h1:ECKVrDLdh/kDPV1g0gAQ+2+m2KprqZK5O/eJAyAnH2M= github.com/nats-io/nats.go v1.44.0/go.mod h1:iRWIPokVIFbVijxuMQq4y9ttaBTMe0SFdlZfMDd+33g= github.com/nats-io/nkeys v0.4.11 h1:q44qGV008kYd9W1b1nEBkNzvnWxtRSQ7A8BoqRrcfa0= github.com/nats-io/nkeys v0.4.11/go.mod h1:szDimtgmfOi9n25JpfIdGw12tZFYXqhGxjhVxsatHVE= github.com/nats-io/nuid v1.0.1 h1:5iA8DT8V7q8WK2EScv2padNa/rTESc1KdnPw4TC2paw= github.com/nats-io/nuid v1.0.1/7go.mod h1:19wcPz3Ph3q0Jbyiqsd0kePYG7A95tJPxeL+1OSON2c= &0h1:HMFp8mLCTPp341M/ZnA4qaf7ZlsbTc+miZjCLOFAw7w= %8/go.mod h1:Fwc5htZGVVkseilnfgOVb9mKy6w1naJmn9CehxcKcls=  0h1:e6DnBTl7vGY+Gz322/ASL4Gyp1FspeMvx1RNDoToZuM=  /go.mod h1:RqIHx9QI14HlwKwm98g9Re5prTQ6LdeRQn+gXJFxsJM= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c h1:+mdjkGKdHQG3305AYmdv1U2eRNDiU2ErMBj1gwrq8eQ= github.com/pkg/browser v0.0.0-20240102092130-5ac0b6a4141c/go.mod h1:7rwL4CYBLnjLxUqIJNnCWiEdr3bn6IUYi15bNlnbCCU= github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4= github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/sftp v1.13.6 h1:JFZT4XbOU7l77xGSpOdW+pwIMqP044IyjXX6FGyEKFo= github.com/pkg/sftp v1.13.6/go.mod h1:tz1ryNURKu77RL+GuCzmoJYxQczL3wLNNpPWagdg4Qk= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2 h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U= github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod h1:iKH77koFhY#xTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= b 0h1:Je96obch5RDVy3FDMndoUsjAhG5Edi49h0RJWRi/o0o= b 8/go.mod h1:Tb1a6LWHB3/SPIzCoaDXI4I8UHKeFTEQ1YCr+0Gyqmg=  0h1:oBsgwpGs7iVziMvrGhE53c/GrLUsZdHnqNwqPLxwZyk=  8/go.mod h1:y3m2F6Gdpfy6Ut/GBsUqTWZqCUvMVzSfMLjcu6wAwpE= ?common v0.68.0 h1:8rQJvQmYltsR2L7h8Zw0Iyj8WYNNmpwikoQTZXwfVeA= Fcommon v0.68.0/go.mod h1:4soH+U8yJSROk7OJ//hmTiWKsxapv6zRGgTt3keN8gQ= %0h1:XwbrGOIplXW/AU3YhIhLODXMJYyC1isLFfYCsTEycfc= $8/go.mod h1:o9EMBZGRyvDrSPH1RqdxhojkuXstoe4UlK79eF5TGGo= B0h1:9bBMbcwroL46feESdJWjRX0GV+k8o/P9gAg9UX6Vz7U= A8/go.mod h1:iW4cSew5PAb1sMZiTEkVJAIBNrepaB6jTYjeP47WtI0= o D0h1:W09IVJc94icq4NjY3clb7Lk8O1qJ8BdBEF8z0ibU0rE= o C/go.mod h1:qqbHyh8v60DhA7CoWK5oRCqLrMHRGoxYCSS9EjAz6Eo= github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0tI/otEQ= github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc= github.com/rs/x 0h1:fV591PaemRlL6JfRxGDEPl69wICngIQ3shQtzfy2gxU= /go.mod h1:7XoLgs4eV+QndskICGsho+ADou8ySMSjJKDIan90Nz0= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= github.com/stretchr/objx v0.5.0/go.mod h1:Yh+to48EsGEfYuaHDzXPcE3xhTkx73EhmCGUpEOglKo= github.com/stretchr/objx v0.5.2/go.mod h1:FRsXN1f5AsAjCGJKqEizvkpNtU+EGNCLh3NxZ/8L+MA= github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U= github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U= github.com/studio-b12/gowebdav v0.11.0 h1:qbQzq4USxY28ZYsGJUfO5jR+xkFtcnwWgitp4Zp1irU= github.com/studio-b12/gowebdav v0.11.0/go.mod h1:bHA7t77X/QFExdeAnDzK6vKM34kEZAcE1OX4MfiwjkE= &0h1:DuWcpNu/FzgEXgGBDp8J1Spc+CWOvvtvVyjKlaZopYU= %8/go.mod h1:LvKtzl2RqO4gyF27BiXU+nKAjcV8f38U+kP/q2vgxh0=  0h1:mOwYbyYDLPj35mkA2BjjYejgJk9BuHxDdvRnb6v2ZcQ=  8/go.mod h1:RSp0LW9oSxFut3KzESt5Voq4GVWyS+PSulT77roAqEA= E #0h1:9j4uCAJyO3IJHygeOdUJNzm6sX3P1+3xuKTbCITQrvc= E "8/go.mod h1:cDOlK/pNYGbGKRNa+NnXDJ1c8R63tWjnTjFKzoSbLv0= u F0h1:gQ+ZV4wJke/EBKYciZ2MshEouEHFuinB85dY3f5s1q8= u E/go.mod h1:jMeV4Vpbi8osrE/pKUxRZkVaA0EX7NZN0A9/oRzgpgY= github.com/zeebo/assert v1.3.0 h1:g7C04CbJuIDKNPFHmsk4hwZDO5O+kntRxzaUo^NXj+IQ= github.com/zeebo/assert v1.3.0/go.mod h1:Pq9JiuJQpG8JLJdtkwrJESF0Foym2/D9XMU5ciN/wJ0= 0h1:s7DLGDK45Dyfg7++yxI0khrfwq9661w9EN78eP/UZVs= /go.mod h1:IisAie1LELR4xhVinxWS5+zf1lA4p0MW4T+w+W07F5s= go.opencensus.io v0.24.0 h1:y73uSU6J157QMP2kn2r30vwW1A2W2WFwSCGnAVxeaD0R= go.opencensus.io v0.24.0/go.mod h1:vNK8G9p7aAivkbmorf4v+7Hgx+Zs0yY+0fOtgBfjQKo= Q0h1:jXsnJ4Lmnqd11kwkBV2LgLoFMZKizbCi5fNZ/ipaZ64= Q8/go.mod h1:KRTj+aOaElaLi+wW1kO/DZRXwkF4C5xPbEe3ZiIhN7Y= Qcontrib/instrumentation/google.golang.org/grpc/otelgrpc v0.46.1 h1:SpGay3w+nEwMpfVnbqOLH5gY52/foP8RE8UzTZ1pdSE= go.opentelemetr`contrib/instrumentation/google.golang.org/grpc/otelgrpc v0.46.1/go.mod h1:4UoMYEZOC0yN/sPGH76KPkkU7zgiEWYWL9vwmbnTJPE= go.opentY bcontrib/instrumentation/net/http/otelhttp v0.46.1 h1:aFJWCqJMNjENlcleuuOkGAPH82y0yULBScfXcIEdS24= Qicontrib/instrumentation/net/http/otelhttp v0.46.1/go.mod h1:sEGXWArGqc3tVa+ekntsN65DmVbVeW+7lTKTjZF3/Fo= Q; 0h1:JjwHmHpA4iZ3wBxluu2fbbE7j4kqlE8jXyAyPXH7HqU= Q@ v1.44.0/go.mod h1:BMgjTHL9WPRlRjL2oZCBTL4whCGtXch2H4BhOPIAyYc= Q(0h1:1w0gILTcHdr3YI+ixLyjemwrVnsMURbTZFrSYCdDdmc= Q'8/go.mod h1:8O7hanEPBNgEMmybD3s2VBKcgWOCsA6tzHBPODAiquo= Q0h1:jxF5CsGYCe74MCRx2X4g7WsY/VBKRqqpNvXlX/6gtIk= Q /go.mod h1:oLl1jrMQAVo6v3GAggN+1VH9VIz9iUSvW53sW1Q8PIE= go.uber.org/goleak v1.3.0 h1:2K3zAYmnTNqV73imy9J1T3WC+gmCePx2hEGkimedGto= go.uber.org/goleak v1.3.0/go.mod h1:CoHD4mav9JJNrW/WLlf7HGZPjdw8EucARQHekz1X6bE= go.uber.org/mock v0.6.0 h1:hyF9dfmbgIX5EfOdasqLsWD6xqpNZlXblLB/Dbnwv3Y= go.uber.org/mock v0.6.0/go.mod h1:KiVJ4BqZJaMj4svdfmHM0AUx4NJYO8ZNpPnZn1Z+BBU= go.yaml.in/yaml/v2 v2.4.4 h1:tuyd0P+2Ont/d6e2rl3be67goVK4R6deVxCUX5vyPaQ= go.yaml.in/yaml/v2 v2.4.4/go.mod h1:gMZqIpDtDqOfM0uNfy0SkpRhvUryYH0Z6wdM YcacYXQ= 0h1:tfq32ie2Jv2UxXFdLJdh3jXuOzWiL1fo0bu/FbuKpbc= /go.mod h1:DhzuOOF2ATzADvBadXxruRBLzYTpT36CKvDb3+aBEFg= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI= golang.org/x/crypto v0.52.0 h1:RMs7fP2rXdep0CftQlK8Uf+kibLm7qkCcradZWYz988= golang.org/x/crypto v0.52.0/g6o.mod h1:1QgfPxDqh0T2M/elOJtp9RvuR95kVjir0e6/BvEmGbc= /40h1:4d4PbuBNwaxMXkXI8yiIYjydtMU+04RHeuSxJdgKftM= /38/go.mod h1:d2fgXJLVs4dYDHUk5lwMIfzRzSrWCfGZb0ZqeLa/Vcw= pY1.1-0.20191105210325-c90efee705ee/go.mod h1:QqPTAvyqsEbceGzBzNggFXnrqF1CaUcvgkdR5Ot7KZg= p0h1:JJjpVx6myfUsUdAzZuOSTTmRE0PfZeNWzzvKrP7amb4= p/go.mod h1:moc6ELqsWcOw5Ef3xVprK5ul/MvtVvkIXLziUOICjUQ= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20190923162816-aa69164e4478/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.0.0-20200114155413-6afb5195e5aa/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= golang.org/x/net v0.55.0 h1:bcvxaJn3e1U6InsFWt1JUq1aSjnRxLzT2rtD2KfkDF8= golang.org/x/net v0.55.0/go.mod h1:L5U2KuzuOe1lY7Z+aWVIKK6qEeJXnXV9yzGA+WCHJww= golang.org/x/oauth2 v0.36.0 h1:peZ/1z27fi9hUOFCAZaHyrpWG5lwe0RJEEEeH0ThlIs= golang.org/x/oauth2 v0.36.0/go.mod h1:YDBUJMTkDnJS+A4BP4eZBjCqtokkg1hODuPjwiGPO7Q= golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM= 0h1:e0PTpb7pjO8GAtTs2dQ6jYa5BWYlMuX047Dco/pItO4= /go.mod h1:9xrNwdLfx4jkKbNva9FpL6vEN7evnE43NNNJQ2LF3+0= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190924154521-2837fb4f24fe/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.45.0 h1:dO4czNzziLiiXplLQgBCEpCvXQ3dnkn0SdaZSYdQ+FY= golang.org/x/sys v0.45.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= golang.org/x/text v0.37.0 h1:Cqjiwd9eSg8e0QAkyCaQTNHFIIzWtidPahFWR83rTrc= golang.org/x/text v0.37.0/go.mod h1:a5sjxXGs9hsn/AJVwuElvCAo9v8QYLzvavO5z2PiM38= golang.org/x/time v0.15.0 h1:bbrp8t3bGUeFOx08pvsMYRTCVSMk89u4tKbNOZbp88U= golang.org/x/time v0.15.0/go.mod h1:Y4YMaQmXwGQZoFaVFk4YpCt4FLQMYKZe9oeV/f4MSno= 0W0.0-20191216052735-49a3e744a425/go.mod h1:TB2adYChydJhpapKDTa4BR/hXlZSLoq2Wpct/0txZ28= 00h1:18qN3FAooORvApf5XjCXgsuayZOEtXf6JK18I3+ONa8= 0/go.mod h1:LuUGqqaXcXMEFEruIVJVm5mgDD8vww/z/SR1gQ4uE/0= golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= gonum.org/v1/gonum v0.17.0 h1:VbpOemQlsSMrYmn7T2OUvQ4dqxQXU+ouZFQsZOx50z4= gonum.org/v1/gonum v0.17.0/go.mod h1:El3tOrEuMpv2UdMrbNlKEh9vd86bmQ6vqIcDwxEOc1E= google.golang.org/api v0.154.0 h1:X7QkVKZBskztmpPKWQXgjJRPA2dJYrL6r+sYPRLj050= google.golang.org/api v0.154.0/go.mod h1:qhSMkM85hgqiokIYsrRyKxrjfBeIhgl4Z2JmeRkYylc= google.golang.org/genproto v0.0.0-20231212172506-995d672761c0 h1:YJ5pD9rF8o9Qtta0Cmy9rdBwkSjrTCT6XTiUQVOtIos= google.golang.org/genproto v0.0.0-20231212172506-995d672761c0/go.mod h1:l/k7rMz0vFTBPy+tFSGvXEd3z+BcoG1k7EHbqm+YBsY= google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9 h1:VPWxll4HlMw1Vs/qXtN7BvhZqsS9cdAittCNvVENElA= google.golang.org/genproto/googleapis/api v0.0.0-20260401024825-9d38bb4040a9/go.mod h1:7QBABkRtR8z+TEnmXTqIqwJLlzrZKVfAUm7tY3yGv0M= google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9 h1:m8qni9SQFH0tJc1X0vmnpw/0t+AImlSvp30sEupozUg= google.golang.org/genproto/googleapis/rpc v0.0.0-20260401024825-9d38bb4040a9/go.mod h1:4Hqkh8ycfw05ld/3BWL7rJOSfebL2Q+DVDeRgYgxUU8= google.golang.org/grpc v1.80.0 h1:Xr6m2WmWZLETvUNvIUmeD5OAagMw3FiKmMlTdViWsHM= google.golang.org/grpc v1.80.0/go.mod h1:ho/dLnxwi3EDJA4Zghp7k2Ec1+c2jqup0bFkw07bwF4= google.golang.org/j0h1:fV6ZwhNocDyBLK0dj+fg8ektcVegBBuEolpbTQyBNVE= X#/go.mod h1:HTf+CrKn2C3g5S8VImy6tdcUvCska2kB7j23XfzDpco= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= gopkg.in/ini.v1 v1.67.2 h1:JtOSMb9OuaCZKr7h5D/h6iii14sK0hLbplTc6frx4Ss= gopkg.in/ini.v1 v1.67.2/go.mod h1:x/cyOwCgZqOkJoDIJ3c1KNHMo10+nLGAhh+kn3Zizss= (0h1:bBRl1b0OH9s/DuPhuXpNl+VtCaJXFZ5/uEFST95x9zc= '/go.mod h1:YD8tP3GAjkrDg1eZH7EGmyESg/lsYskCTPBJVb9jqSc= gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= modernc.org/cc/v4 v4.28.2 h1:3tQ0lf2ADtoby2EtSP+J7IE2SHwEJdP8ioR59wx7XpY= modernc.org/cc/v4 v4.28.2/go.mod h1:OnovgIhbbMXMu1aISnJ0wvVD1KnW+cAUJkIrAWh+kVI= modernc.org/ccgo/v4 v4.34.2 h1:mxsy2FdrB6+qG3NfXefz1AmWv0ehOSDO4jxgxd7h9yo= modernc.org/ccgo/v4 v4.34.2/go.mod h1:1L7us56+kAKu04p25EATpmBBvhbcqqZ85ibqWVwVgog= modernc.org/fileutil v1.4.0 h1:j6ZzNTftVS054gi281TyLjHPp6CPHr2KCxEXjEbD6SM= modernc.org/fileutil v1.4.0/go.mod h1:EqdKFDxiByqxLk8ozOxObDSfcVOv/54xDs/DUHdvCUU= modernc.org/gc/v2 v2.6.5 h1:nyqdV8q46KvTpZlsw66kWqwXRHdjIlJOhG6kxiV/9xI= modernc.org/gc/v2 v2.6.5/go.mod h1:YgIahr1ypgfe7chRuJi2gD7DBQiKSLMPgBQe9oIiito= modernc.org/gc/v3 v3.1.3 h1:6QAplYyVO+KdPW3pGnqmJDUxtkec8ooEWvks/hhU3lc= modernc.org/gc/v3 v3.1.3/go.mod h1:HFK/6AGESC7Ex+EZJhJ2Gni6cTaYpSMmU/cT9RmlfYY= modernc.org/goabi0 v0.2.0 h1:HvEowk7LxcPd0eq6mVOAEMai46V+i7Jrj13t4AzuNks= modernc.org/goabi0 v0.2.0/go.mod h1:CEFRnnJhKvWT1c1JTI3Avm+tgOWbkOu5oPA8eH8LnMI= modernc.org/libc v1.72.5 h1:m2OGx9Ser1VvTS4Z9ZJlWs+CBMxutLaTiAWkNz+NB9U= modernc.org/libc v1.72.5/go.mod h1:np0N7KDJ7eUtMZmOqVZNldrZyG+DHLl2B5pg8Hbar3U= 0h1:GCZVGXdaN8gTqB1Mf/usp1Y/hSqgI2vAGGP4jZMCxOU= /go.mod h1:4p5IwJITfppl0G4sUEDtCr4DthTaT47/N3aT6MhfgJg= modernc.org/memory v1.11.0 h1:o4QC8aMQzmcwCK3t3Ux/ZHmwFPzE6hf2Y5LbkRs+hbI= modernc.org/memory v1.11.0/go.mod h1:/JP4VbVC+K5sU2wZi9bHoq2MAkCnrt2r98UGeSK7Mjw= modernc.org/opt v0.2.0 h1:tGyef5ApycA7FSEOMraay9SaTk5zmbx7Tu+cJs4QKZg= modernc.org/opt v0.2.0/go.mod h1:03fq9lsNfvkYSfxrfUhZCWPk1lm4cq4N+Bh//bEtgns= modernc.org/sortutil v1.2.1 h1:+xyoGf15mM3NMlPDnFqrteY07klSFxLElE2PVuWIJ7w= modernc.org/sortutil v1.2.1/go.mod h1:7ZI3a3REbai7gzCLcotuw9AC4VZVpYMj DzETGsSMqJE= Z0h1:aH/MMSoayAIhozZ7uJbVTT9QO/VhzBf0J9tymmmuC/U= Z/go.mod h1:tcNzv5p84E0skkmJn038y+hWJbLQXQqEnQfeh5r2JLM= modernc.org/strutil v1.2.1 h1:UneZBkQA+DX2Rp35KcM69cSsNES9ly8mQWD71HKlOA0= modernc.org/strutil v1.2.1/go.mod h1:EHkiggD70koQxjVdSBM3JKM7k6L0FbGE5eymy9i3B9A= modernc.org/token v1.1.0 h1:Xl7Ap9dKaEs5kpLoOQeQmPWevfnk/DM5qcLcYlA8ys6Y= modernc.org/token v1.1.0/go.mod h1:UGzOrNV1mAFSEB63lOFHIpNRUVMvYTc6yu1SMY/XTDM= ,F40000 workflows�n8TV/_9StKݦx&�100644 docker.yml�h̽gȱ@]&`x� runs-on:aorxO�@[$rQjٓU!T8%M w8-HﳠO[>LbgX) i}b d;xE40000 .github�;:5̄, 48100644 .gitignore�' À !6œ㝶>100644 CLAUDE.md�`(z52v#c100644 Dockerfile�\\QjqBq100644 LICENSE�<:MdPR100644 LICENSING.md�__"]+Ұ?Y120000 LLM.md�hSsW{100644 README.md�o&;bkܛVv4100644 chains.example.yaml�[$rQjٓU!100644 compose.yml�>)S7>rš 100644 config.go�%M w8-H100644 frontend.go�Y�kV aB28q·100644 frontend_test.go�(xN2}୫GR]#|+100644 go.mod�E5ug)BLF9,q100644 go.sum�|S)B(2(ڂI100644 main.go� G/נs܁100644 mdns.go�_ֈm2mWw1<&vܢXN100644 realtime.go�zYW/rb4gӌ100644 realtime_sse.go�Z*ڶ%e&100644 realtime_test.go�2-CGM"100644 registry.go�o:źZj+F)pL100644 registry_test.go�Ys5Z�C40000 scripts�B:N~=w$=^+E40000 static�V,ԂyAXtoo100644 supervisor.go�O[>LbgX) i}b zKGx~�kTMJ+ P @|b -RlAFW=100644 frontend_test.go�/Řf G h!dYYjP%+?)C8 x+�"40000 .github�=rP!FZ=vf"Kw9xsq uqM�  x�OO;vh&:UQ ^x&�100644 docker.yml�&bceJx06package main import ( "bytes" "embed" "encoding/json" "fmt" "io/fs" "net/http" "os" "path/filepath" "strings" "sync" ) // staticFS is the embedded SPA. The Dockerfile populates static/ from a // luxfi/explore build before the Go build runs; for local dev a placeholder // index.html is committed so go:embed always succeeds. // //go:embed all:static var staticFS embed.FS // Frontend serves the embedded SPA, runtime config (/envs.js), and per-host // brand assets (/icon.svg, /logo.svg). Brand assets read from disk on every // request so a deploy can swap them without rebuilding the binary. // // SPA override: if cfg.StaticDir (or $EXPLORER_STATIC_DIR) points at an // existing directory, file lookups prefer the on-disk copy over the // embedded FS. This lets a ConfigMap-mounted SPA replace the embedded // 60-byte placeholder without a binary rebuild — useful when the // upstream `explore` Next.js app hasn't shipped a static export yet but // we want a richer in-cluster default than `
`. type Frontend struct { cfg Config registry *ChainRegistry root fs.FS // embedded SPA (always present) overlay fs.FS // disk overlay (nil if cfg.StaticDir not set) index []byte // resolved index.html (overlay > embedded > builtin) } // NewFrontend returns a frontend handler bound to a config and chain registry. func NewFrontend(cfg Config, r *ChainRegistry) (*Frontend, error) { root, err := fs.Sub(staticFS, "static") if err != nil { return nil, err } f := &Frontend{cfg: cfg, registry: r, root: root} dir := cfg.StaticDir if dir == "" { dir = os.Getenv("EXPLORER_STATIC_DIR") } if dir != "" { if st, err := os.Stat(dir); err == nil && st.IsDir() { f.overlay = os.DirFS(dir) } } if data := f.readStatic("index.html"); data != nil { f.index = data } else { f.index = []byte("Explorer") } return f, nil } // readStatic returns the bytes for `name` from the overlay if present, // otherwise from the embedded FS. Returns nil if neither has the file. func (f *Frontend) readStatic(name string) []byte { if f.overlay != nil { if data, err := fs.ReadFile(f.overlay, name); err == nil { return data } } if data, err := fs.ReadFile(f.root, name); err == nil { return data } return nil } // Mount installs / (SPA), /envs.js, /icon.svg, /logo.svg on mux. func (f *Frontend) Mount(mux *http.ServeMux) { mux.HandleFunc("GET /envs.js", f.handleEnvs) mux.HandleFunc("GET /icon.svg", f.handleIcon) mux.HandleFunc("GET /logo.svg", f.handleLogo) mux.HandleFunc("/", f.handleSPA) } // handleSPA serves embedded static assets and falls back to index.html for // any path the SPA owns (client-side routing). // // HEAD-method note: the bundled SPA opens EventSource (Server-Sent Events) // channels for live block / token / tx streams and pre-flights each URL // with a HEAD request: // // fetch(url, {method: 'HEAD'}).then(r => r.ok ? openEventSource() : disable()); // // If we serve a 200 (because of the SPA fallback to index.html), the SPA // proceeds to open the EventSource — which then immediately aborts because // the response body is text/html, not text/event-stream. Browser logs // "EventSource's response has a MIME type ('text/html') that is not // 'text/event-stream'" for every channel on every page load — noisy and // disables the channel anyway. // // Fix: return 404 for HEAD requests on the SPA-fallback path. Real assets // (anything in `f.root`) still serve normally on HEAD; only the index.html // fallback gets the 404 so the SSE pre-flight cleanly fails and the SPA // disables that channel on its own. Visible browser load is unchanged // because the SPA only HEAD-probes its SSE endpoints, never the SPA URL // itself. func (f *Frontend) handleSPA(w http.ResponseWriter, r *http.Request) { p := strings.TrimPrefix(r.URL.Path, "/") if p == "" { if r.Method == http.MethodHead { http.NotFound(w, r) return } f.writeIndex(w) return } // Overlay wins if it has the file (any non-directory entry); falls // back to embedded; falls back to index.html (SPA-routing). if f.overlay != nil { if file, err := f.overlay.Open(p); err == nil { st, statErr := file.Stat() file.Close() if statErr == nil && !st.IsDir() { http.ServeFileFS(w, r, f.overlay, p) return } } } file, err := f.root.Open(p) if err != nil { if r.Method == http.MethodHead { http.NotFound(w, r) return } f.writeIndex(w) return } defer file.Close() stat, err := file.Stat() if err != nil || stat.IsDir() { if r.Method == http.MethodHead { http.NotFound(w, r) return } f.writeIndex(w) return } http.ServeFileFS(w, r, f.root, p) } func (f *Frontend) writeIndex(w http.ResponseWriter) { w.Header().Set("Content-Type", "text/html; charset=utf-8") w.Header().Set("Cache-Control", "no-cache") w.Write(f.index) } // handleEnvs returns runtime config the SPA reads instead of build-time env // vars. This is what makes per-network customization possible without a // rebuild: deploy the same image, mount a different chains.yaml, get a // different brand + chain list. func (f *Frontend) handleEnvs(w http.ResponseWriter, r *http.Request) { hostBrand := f.brandForHost(r.Host) hostSlug := f.chainSlugForHost(r.Host) chains := f.chainListJSON() // When the host pins a specific chain (e.g. explore.zoo.network → // zoo, explorer.zoo-test.network → zoo), promote that chain to // default and demote any other config-level default. The SPA's chain // switcher honours the "default" flag. if hostSlug != "" { for i := range chains { if chains[i]["slug"] == hostSlug { chains[i]["default"] = true } else { chains[i]["default"] = false } } } env := map[string]any{ "VITE_CHAINS": chains, "VITE_NETWORKS": f.cfg.Networks, "VITE_BRAND": hostBrand, } body, _ := json.Marshal(env) var buf bytes.Buffer buf.WriteString("window.ENV = ") buf.Write(body) buf.WriteString(";\n") w.Header().Set("Content-Type", "application/javascript") w.Header().Set("Cache-Control", "no-cache") w.Write(buf.Bytes()) } // handleIcon serves the per-host or default icon.svg from disk. func (f *Frontend) handleIcon(w http.ResponseWriter, r *http.Request) { f.serveBrandFile(w, r, func(b Brand) string { return b.IconFile }, "icon.svg") } // handleLogo serves the per-host or default logo.svg from disk. func (f *Frontend) handleLogo(w http.ResponseWriter, r *http.Request) { f.serveBrandFile(w, r, func(b Brand) string { return b.LogoFile }, "logo.svg") } // serveBrandFile resolves the file path from the matched brand (per-chain or // default) and sends it. Falls back to the on-disk overlay (if configured) // then the embedded SPA's named asset. func (f *Frontend) serveBrandFile(w http.ResponseWriter, r *http.Request, pick func(Brand) string, fallback string) { brand := f.brandStruct(r.Host) if path := pick(brand); path != "" { if data, err := os.ReadFile(path); err == nil { w.Header().Set("Content-Type", contentTypeFor(path)) w.Header().Set("Cache-Control", "public, max-age=300") w.Write(data) return } } if data := f.readStatic(fallback); data != nil { w.Header().Set("Content-Type", contentTypeFor(fallback)) w.Header().Set("Cache-Control", "public, max-age=300") w.Write(data) return } http.NotFound(w, r) } // brandForHost returns a JSON-shaped brand for /envs.js. It strips file paths. func (f *Frontend) brandForHost(host string) map[string]any { b := f.brandStruct(host) return map[string]any{ "name": b.Name, "coin": b.Coin, "accentColor": b.AccentColor, "iconUrl": b.IconURL, "logoUrl": b.LogoURL, } } // brandStruct returns the Brand for a request host: a chain whose name or // slug matches the hostname wins; otherwise the global default. // // See hostMatchesSlug for the list of supported hostname shapes. func (f *Frontend) brandStruct(host string) Brand { if c, ok := f.matchChain(host); ok && c.Brand != nil { return *c.Brand } return f.cfg.BrandDefault } // chainSlugForHost returns the slug of the chain pinned by the request host, // or "" if the host does not name a chain. Used by handleEnvs to promote a // per-host chain to the SPA's default selection. func (f *Frontend) chainSlugForHost(host string) string { if c, ok := f.matchChain(host); ok { return c.Slug } return "" } // matchChain finds the first configured chain whose slug appears in the // request host. Matches these hostname shapes, in order of specificity: // - "{slug}" — bare slug (curl localhost) // - "{slug}.tld..." — {slug}.lux.network, {slug}.hanzo.ai // - "explore-{slug}.tld..." — explore-hanzo.lux.network // - "explorer-{slug}.tld..." — explorer-hanzo.lux.network // - "api-explore-{slug}.tld..." — api-explore-hanzo.lux.network // - "explore.{slug}.tld..." — explore.hanzo.ai, explore.zoo.ngo // - "explorer.{slug}.tld..." — explorer.hanzo.ai, explorer.zoo.network // - "api-explore.{slug}.tld..." — api-explore.hanzo.ai // - "explore-{slug}-{env}.tld..." — explore-hanzo-test.lux.network // - "explorer-{slug}-{env}.tld..." — explorer-hanzo-test.lux.network // - "api-explore-{slug}-{env}.tld..." — api-explore-hanzo-dev.lux.network // - "explore.{slug}-{env}.tld..." — explore.zoo-test.network // - "explorer.{slug}-{env}.tld..." — explorer.zoo-test.network // - "api-explore.{slug}-{env}.tld..." — api-explore.zoo-test.network // // First chain match wins on ambiguous hosts. func (f *Frontend) matchChain(host string) (ChainConfig, bool) { host = strings.ToLower(strings.SplitN(host, ":", 2)[0]) for _, c := range f.cfg.Chains { if hostMatchesSlug(host, c.Slug) { return c, true } } return ChainConfig{}, false } // hostMatchesSlug is the pure string predicate for chain↔host matching. // Kept separate from matchChain so unit tests can cover it directly. func hostMatchesSlug(host, slug string) bool { if slug == "" { return false } if host == slug { return true } // Direct slug-as-subdomain: zoo.lux.network, hanzo.ai. if strings.HasPrefix(host, slug+".") || strings.HasPrefix(host, slug+"-") { return true } // Brand-owned domains: explore.zoo.network, explorer.zoo-test.network, // api-explore.zoo.ngo, etc. Each "explore"/"explorer" prefix combines // with "." or "-" as the slug separator. prefixes := []string{ "explore-", "explorer-", "api-explore-", "api-explorer-", "explore.", "explorer.", "api-explore.", "api-explorer.", } for _, p := range prefixes { // {prefix}{slug}.tld — e.g. explore.zoo.network, explore-zoo.lux.network if strings.HasPrefix(host, p+slug+".") { return true } // {prefix}{slug}-{env}.tld — e.g. explore-zoo-test.lux.network, // explorer.zoo-test.network if strings.HasPrefix(host, p+slug+"-") { return true } } return false } // chainListJSON returns a SPA-friendly chain list from the live registry, // not the static config — chains added via mDNS/admin show up immediately. var chainListMu sync.Mutex func (f *Frontend) chainListJSON() []map[string]any { chainListMu.Lock() defer chainListMu.Unlock() out := []map[string]any{} if f.registry == nil { return out } for _, c := range f.registry.List() { out = append(out, map[string]any{ "slug": c.Slug, "name": c.Name, "chainId": c.ChainID, "rpc": c.RPC, "coin": c.CoinSymbol, "type": c.Type, "default": c.Default, }) } return out } // contentTypeFor maps a file extension to a Content-Type, defaulting to // application/octet-stream. func contentTypeFor(path string) string { switch strings.ToLower(filepath.Ext(path)) { case ".svg": return "image/svg+xml" case ".png": return "image/png" case ".jpg", ".jpeg": return "image/jpeg" case ".webp": return "image/webp" case ".ico": return "image/x-icon" default: return "application/octet-stream" } } // fingerprint returns a short, stable identifier for the embedded asset // bundle, useful for cache-busting log lines at startup. func fingerprint() string { root, err := fs.Sub(staticFS, "static") if err != nil { return "0" } count := 0 _ = fs.WalkDir(root, ".", func(_ string, _ fs.DirEntry, _ error) error { count++ return nil }) return fmt.Sprintf("assets=%d", count) } Wx?a<net/http" "net/http/httptestT&testing" ) // TestFrontendStaticOverlay verifies that NewFrontend prefers the on-disk // static dir over the embedded FS when cfg.StaticDir points at a real // directory. The overlay use-case: ConfigMap-mounting a richer SPA shell // into an existing image without rebuilding. func TestFrontendStaticOverlay(t *testing.T) { dir := t.TempDir() want := "OVERLAY" if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte(want), 0644); err != nil { t.Fatal(err) } cfmg := Config{StaticDir: dir, BrandDefault: Brand{Name: "Test"}} f, err := NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } mux := http.NewServeMux() f.Mount(mux) req := httptest.NewRequest("GET", "/", nil) rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) got := rec.Body.String() if !strings.Contains(got, "OVERLAY") { t.Fatalf("expected overlay index.html, got %q", got) } } // TestFrontendNoOverlay verifies that with no StaticDir, the embedded // index.html is served (current behaviour — pre-overlay). func TestFrontendNoOverlay(t *testing.T) { cfg := Config{BrandDefault: Brand{Name: "Tes3t"}} f, err := NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } if f.overlay != nil { t.Fatal("expected nil overlay when StaticDir empty") } mux := http.NewServeMux() f.Mount(mux) req := httptest.NewRequest("GET", "/", nil) rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) got := rec.Body.String() if !strings.Contains(got, "doctype html") { t.Fatalf("expected fallback index.html, got %q", got) } } // TestFrontendOverlayMissingFileFallsBack covers the case where the // overlay dir exists but a particular file is missing — the request // falls through to the embedded FS (and ultimately to index.html for // SPA-routing). func TestFrontendOverlayMissingFileFallsBack(t *testing.T) { dir := t.TempDir() // Only index.html in overlay; no other assets. if err := os.WriteFile(filepath.Join(dir, "index.html"),?OVERLAY"), 0644); err != nil { t.Fatal(err) } cfg := Config{StaticDir: dir, BrandDefault: Brand{Name: "Test"}} f, err := #NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } mux := http.NewServeMux() f.Mount(mux) // Request a path the overlay doesn't have. With SPA-routing, the // handler returns index.html — which IS in the overlay. req := httptest.NewRequest("GET", "/some/spa/route", nil) rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) got := rec.Body.String() if !strings.Contains(got, "OVERLAY") { t.Fatalf("expected overlay index.html (SPA fallback), got %q", got) } } // TestFrontendEnvStaticDir verifies $EXPLORER_STATIC_DIR is the env-var // equivalent of cfg.StaticDir. Empty cfg + env-var-set overlay should // still pick up the overlay. func TestFrontendEnvStaticDir(t *testing.T) { dir := t.TempDir() if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte("ENV-OVERLAY"), 0644); err != nil { t.Fatal(err) } t.Setenv("EXPLORER_STATIC_DIR", dir) cfg := Config{BrandDefault: Brand{Name: "Test"1}} f, err := NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } if f.overlay == nil { t.Fatal("expected overlay populated from env var") } if !strings.Contains(string(f.index), "ENV-OVERLAY") { t.Fatalf("expected env-overlay index, got %q", string(f.index)) } } // TestBrandStructHostMatching covers every hostname shape the unified // explorer's IngressRoutes hand it: the per-chain brand must win over // BrandDefault for both UI hosts (explore-{slug}, explore.{slug}.tld) // and API hosts (api-explore-{slug}). The matcher must NOT bleed across // chains — a hanzo host must not pick zoo's brand or vice versa. func TestBrandStructHostMatching(t *testing.T) { hanzoBrand := Brand{Name: "Hanzo", Coin: "AI", AccentColor: "#0b1220"} zooBrand := Brand{Name: "Zoo", Coin: "ZOO", AccentColor: "#7c3aed"} cfg := Config{ BrandDefault: Brand{Name: "Lux Explorer"}, Chains: []ChainConfig{ {Slug: "cchain", Brand: &Brand{Name: "Lux C-Chain", Coin: "LUX"}}, {Slug: "hanzo", Brand: &hanzoBrand}, {Slug: "zoo", Brand: &zooBrand}, }, } f, err :%= NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } cases := []struct { host string want string }{ // Bare slug + slug-prefix shape. {"hanzo", "Hanzo"},` {"hanzo.lux.network", "Hanzo"}, // explore-{slug} prefix shape (lux.network UI hosts). {"="", "Hanzo"}, {"$?", "Hanzo"}, {"explore-hanzo-dev.lux.network", "Hanzo"}, {" *Q", "Zoo"}, // api-explore-{slug} prefix shape (lux.network API hosts). {"api-="", "Hanzo"}, {"api-$", "Hanzo"}, {"api- *", "Zoo"}, // explore.{slug}.tld shape (brand-owned domains). {"explore.hanzo.ai", "Hanzo"}, {"explore.hanzo.network", "Hanzo"}, {"explore.zoo.network", "Zoo"}, {"explore.zoo.ngo", "Zoo"}, {"api-explore.hanzo.ai", "Hanzo"}, {"api-explore.zoo.ngo", "Zoo"}, // explorer.{slug}.tld shape (alias of explore.* for brand-owned domains). {"explorer.zoo.network", "Zoo"},f {"explorer.hanzo.ai", "Hanzo"}, // {slug}-{env}.tld shape — brand-owned testnet/devnet domains.*% is the primary case this fixes. {"*", "Zoo"}, {"%?", "Zoo"}, {"explorer.hanzo-test.network", "Hanzo"}, {"api-%", "Zoo"}, // Mismatched hosts fall back to BrandDefault. {"explore.lux.network", "Lux Explorer"}, {"unknown.example.com", "Lux Explorer"}, // Cross-contamination guard: explore-spcfoo must NOT match spc. {"explore-spcfoo.lux.network", "Lux Explorer"}, // Cross-contamination guard: zoofoo must NOT match zoo. {"explore.zoofoo.network", "Lux Explorer"}, {"explorer.zoofoo.network", "Lux Explorer"}, } for _, tc := range cases { t.Run(tc.host, func(t *testing.T) { got := f.brandStruct(tc.host).Name if got != tc.want { t.Fatalf("host=%q: got brand=%q, want %q", tc.host, got, tc.want) } }) } } // TestChainSlugForHost covers the host→default-chain promotion that // handleEnvs uses to set the SPA's initial chain selection. Hosts that // pin a chain ( *() must // return the slug; generic hosts (explore.lux.network) must return "". func TestChainSlugForHost(t *testing.T) { zooBrand := Brand{Name: "Zoo"} hanzoBrand := Brand{Name: "Hanzo"} cfg := Config{ BrandDefault: Brand{Name: "Lux Explorer"}, Chains: []ChainConfig{ {Slug: "cchain", Brand: &Brand{Name: "Lux C-Chain"}}, {Slug: "hanzo", Brand: &hanzoBrand}, {Slug:Q "zoo", Brand: &zooBrand}, }, } f, err := NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } cases := []struct { host string want string }{ {"explore.zoo.network", "zoo"}, {"explore.zoo.ngo", "z-oo"}, {"explorer.zoo.network", "zoo"}, {"*", "zoo"}, {"%", "zoo"}, {" *", "zoo"}, {"*", "zoo"}, {"explore.hanzo.ai", "hanzo"}, {"explorer.hanzo-test.network", "hanzo"}, // Generic / mismatched hosts: no slug. {"explore.lux.network", ""}, {"unknown.example.com", ""}, {"explore.zoofoo.network", ""}, } for _, tc := range cases/ { t.Run(tc.host, func(t *testing.T) { gotttc.host) if got != tc.want { t.Fatalf("host=%q: got slug=%q, want %q", tc.host, got, tc.want) } }) } } ,g5OxG<;bytes" "embed" "encoding/json" "fmt" "io/fs" "net/http6&sync" ) // staticFS is the embedded SPA. The Dockerfile populates static/ from a // luxfi/explore build before the Go build runs; for local dev a placeholder // index.html is committed so go:embed always succeeds. // //go:embed all:static var staticFS embed.FS // Frontend serves the embedded SPA, runtime config (/envs.js), and per-host // brand assets (/icon.svg, /logo.svg). Brand assets read from disk on every // request so a deploy can swap them without rebuilding the binary. // // SPA override: if cfg.StaticDir (or $EXPLORER_STATIC_DIR) points at an // existing directory, file lookups prefer the on-disk copy over the // embedded FS. This lets a ConfigMap-mounted SPA replace the embedded // 60-byte placeholder without a binary rebuild — useful when the // upstream `explore` Next.js app hasn't shipped a static export yet but // we want a richer in-cluster default than ``. type Frontend struct { cfg Config registry *ChainRegistry root fs.FS // embedded SPA (always present) overlay fs.FS // disk overlay (nil if cfg.StaticDir not set) index []byte // resolved index.html (overlay > embedded > builtin) } // NewFrontend returns a frontend handler bound to a config and chain registry. func NewFrontend(cfg Config, r *ChainRegistry) (*Frontend, error) { root, err := fs.Sub(staticFS, "static") if err != nil { return nil, err } f f := &Frontend{cfg: cfg, registry: r, root: root} dir := cfg.StaticDir if dir == "" { dir = os.G) ) } if dir != "" { if st, err := os.Stat(dir); err == nil && st.IsDir() { f.overlay = os.DirFS(dir) } } if data := Xf.readStatic("index.html"); data != nil { f.index = data } else { f.index = []byte(Explorer") } return f, nil } // readStatic returns the bytes for `name` from the overlay if present, // otherwise from the embedded FS. Returns nil if neither has the file. func (f *Frontend) readStatic(name string) []byte { if f.overlay != n@if data, err := fs.ReadFile(f.overlay, name); err == nil { return data } } if data, err := fs.ReadFile(f.root, name); err == nil { return data } return nil } // Mount installs / (SPA), /envs.js, /icon.svg, /logo.svg on mux. func (f *Frontend) Mount(mux *http.ServeMux) { mux.HandleFunc("GET /envs.js", f.handleEnvs) mux.HandleFunc("GET /icon.svg", f.handleIcon) mux.HandleFunc("GET /logo.svg", f.handleLogo) mux.HandleFunc("/", f.handleSPA) } // handleSPA serves embedded static assets and falls back to index.html for // any path the SPA owns (client-side routing). // // HEAD-method note: the bundled SPA opens EventSource (Server-Sent Events) // channels for live block / token / tx streams and pre-flights each URL // with a HEAD request: // // fetch(url, {method: 'HEAD'}).then(r => r.ok ? openEventSource() : disable()); // // If we serve a 200 (because of the SPA fallback to index.html), the SPA // proceeds to open the EventSource — which then immediately aborts because // the response body is text/html, not text/event-stream. Browser logs // "EventSource's response has a MIME type ('text/html') that is not // 'text/event-stream'" for every channel on every page load — noisy and // disables the channel anyway. // // Fix: return 404 for HEAD requests on the SPA-fallback path. Real assets // (anything in `f.root`) still serve normally on HEAD; only the index.html // fallback gets the 404 so the SSE pre-flight cleanly fails and the SPA // disables that channel on its own. Visible browser load is unchanged // because the SPA only HEAD-probes its SSE endpoints, never the SPA URL // itself. func (f *Frontend) handleSPA(w http.ResponseWriter, r *http.Request) { p := strings.TrimPrefix(r.URL.Path, "/") if p == "" { if r.Method == http.MethodHead { http.NotFound(w, r) return } f.writeIndex(w) return } // Overlay wins if it has the file (any non-dirRectory entry); falls // back to embedded; falls back to index.html (SPA-routing).-if file, err := f.overlay.Open(p); err == nil { st, statErr := file.Stat() file.Close() if statErr == nil && !st.IsDir() { http.ServeFileFS(w, r, f.overlay, p) return } } } file, err := f.root.Open(p) if err != nil { if r.Method == http.MethodHead { http.NotFound(w, r) return } f.writeIndex(w) return } defer file.Close() stat, err := file.Stat() if err != nil || stat.IsDir() { if r.Method == http.MethodHead { http.NotFound(w, r) return } f.writeIndex(w) return } http.ServeFileFS(w, r, f.root, p) } func (f *Frontend) writeIndex(w http.ResponseWriter) { w.Header().Set("Content-Type", "text/html; charset=utf-8") w.Header().Set("Cache-Control", "no-cache") w.Write(f.index) } // handleEnvs returns runtime config the SPA reads instead of build-time env // vars. This is what makes per-network customization possible without a // rebuild: deploy the same image, mount a different chains.yaml, get a // different brand + chain list. func (f *Frontend) handleEnvs(w http.ResponseWriter, r *http.Request) { hostBrand := f.brandForHost(r.Host) hostSlug := f.chainSlugForHost(r.Hoost) chains := f.chainListJSON() // When the host pins a specific chain (e.g. explore.zoo.network → // zoo! → zoo), promote that chain to // default and demote any other config-level default. The SPA's chain // switcher honours the "default" flag. if hostSlug != "" { for i := range chains { if chains[i]["slug"] == hostSlug { chains[i]["default"] = true } else { chains[i]["default"] = false } } } current, peers := f.networksForHost(r.Host) env := map[string]any{ "VITE_CHAINS": chains, "VITE_NETWORKS": f.cfg.Networks, "VITE_BRAND": hostBrand, "VITE_CURRENT_NETWORK": current, "VITE_NETWORK_HOSTS": peers, } body, _ := json.Marshal(env) var buf bytes.Buffer buf.WriteString("window.ENV = ") buf.Write(body) buf.WriteString(";\n") w.Header().Set("Content-Type", "application/javascript") w.Header().Set("Cache-Control", "no-cache") w.Write(buf.Bytes()) } // handleIcon serves the per-host or default icon.svg from disk. func (f *Frontend) handleIcon(w http.ResponseWriter, r *http.Request) { f.serveBrandFile(w, r, func(b Brand) string { return b.IconFile }, "icon.svg") } // handleLogo serves the per-host or default logo.svg from disk. func (f *Frontend) handleLogo(w http.ResponseWriter, r *http.Request) { f.serveBrandFile(w, r, func(b Brand) string { return b.LogoFile }, "logo.svg") } // serveBrandFile resolves the file path from the matched brand (per-chain or // default) and sends it. Falls back to the on-disk overlay (if configured) // then the embedded SPA's named asset. func (f *Frontend) serveBrandFile(w http.ResponseWriter, r *http.Request, pick func(Brand) string, fallback string) { brand := f.brandStruct(r.Host) if path := pick(brand); path != "" { if data, err := os.ReadFile(path); err == nil { w.Header().Set("Content-Type", contentTypeFor(path)) w.Header().Set("Cache-Control", "public, max-age=300") w.Write(data) return } } if data := f.readStatic(fallback); data != nil { w.Header().Set("Content-Type", contentTypeFor(fallback)) w.Header().Set("Cache-Control", "public, max-age=300") w.Write(data)  return } http.NotFound(w, r) } // brandForHost returns a JSON-shaped brand for /envs.js. It strips file paths. func (f *Frontend) brandForHost(host string) map[string]any { b := f.brandStruct(host) return map[string]any{ "name": b.Name,  "coin": b.Coin, "accentColor": b.AccentColor, "iconUrl": b.IconURL, "logoUrl": b.LogoURL, } } // brandStruct returns the Brand for a request host: a chain whose name or // slug matches the hostname wins; otherwise the global default. // // See hostMatchesSlug for the list of supported hostname shapes. func (f *Frontend) brandStruct(host string) Brand { if c, ok := f.matchChain(host); ok && c.Brand != nil { return *c.Brand } return f.cfg.BrandDefault } // chainSlugForHost returns the slug of the chain pinned by the request host, // or "" if the host does not name a chain. Used by handleEnvs to promote a // per-host chain to the SPA's default selection. func (f *Frontend) chainSlugForHost(host string) string { if c, ok := f.matchChain(host); ok { return c.Slug } return "" } // matchChain finds the first configured chain whose slug appears in the // request host. Matches these hostname shapes, in order of specificity: // - "{slug}" — bare slug (curl localhost) // - "{slug}.tld..." — {slug}.lux.network, {slug}.hanzo.ai // - "explore-{slug}.tld..." —  // - "explorer-{slug}.tld..." — explorer-hanzo.lux.network // - "api-explore-{slug}.tld..." — api // - "explore.{slug}.tld..." — explore.hanzo.ai, explore.zoo.ngo // - "explorer.{slug}.tld..." — explorer.hanzo.ai, explorer.zoo.network // - "api-explore.{slug}.tld..." — api-explore.hanzo.ai // - "explor"e-{slug}-{env}.tld..." —  // - "explorer-{slug}-{env}.tld..." — explorer-hanzo-test.lux.network // - "api-explore-{slug}-{env}.tld..."  api-+1 // - "explore.{slug}-{env}.tld..." — 0 // - "explorer.{slug}-{env}.tld..." —!1 // - "api-explore.{slug}-{env}.tld..." —  // // First chain match wins on ambiguous hosts. func (f *Frontend) matchChain(host string) (ChainConfig, bool) { host = strings.ToLower(strings.SplitN(host, ":", 2)[0]) for _, c := range f.cfg.Chains { if hostMatchesSlug(host, c.Slug) { return c, true } } return ChainConfig{}, false } // hostMatchesSlug is the pure string predicate for chain↔host matching. // Kept separate from matchChain so unit tests can cover it directly. func hostMatchesSlug(host, slug string) bool { if slug == "" { return false } if host == slug { return true } // Direct slug-as-subdomain: zoo.lux.network, hanzo.ai. if strings.HashPrefix(host, slug+".") || strings.HasPrefix(host, slug+"-") { return true } // Brand-owned domains: ., // api-explore.zoo.ngo, etc. Each "explore"/"explorer" prefix combines // with "." or "-" as the slug separator. prefixes := []string{ "explore-", "explorer-", "api-explore-", "api-explorer-", "explore.", "explorer.", "api-explore.", "api-exMplorer.", } for _, p := range prefixes { // {prefix}{slug}.tld — e.g. -zoo.lux.network if strings.HasPrefix(host, p+slug+".") { return true } // {prefix}{slug}-{env}.tld — e.g. explore-zI, if strings.HasPrefix(host, p+slug+"-") { return true } } return false } // networksForHost returns (current network label, sibling host map). The // SPA renders a "Network: mainnet ▾" dropdown — when the user picks // another label, the SPA redirects to the corresponding host. Hosts are // derived purely from the request host: explore.zoo.network (mainnet) // has sibling!(testnet); explore.lux.network // has sibling explorer.lux-test.network; and the reverse. // // Host shape rules: // - mainnet: prefix is "explore.", brand domain is "." // (e.g. zoo.network, lux.network, hanzo.ai). Sibling is // "explorer.-test.network". // - testnet: prefix is "explorer.", brand domain is "-test.network". // Sibling is "explore..network" (or .ai / .ngo per brand // when known; we default to .network because all the actual // deployed testnet hosts are *.network). // - lux.network (no brand prefix, generic explore.lux.network) is // special-cased: mainnet=explore.lux.network, testnet=explorer.lux-test.network. // // If we can't classify the host (admin tooling on localhost, internal // service-mesh hostnames), we return ("", nil) and the SPA omits the // dropdown. func (f *Frontend) networksForHost(host string) (string, map[string]string) { host = strings.ToLower(strings.SplitN(host, ":", 2)[0]) // Find the brand stem and current env from the host. The two // shapes we support are "{prefix}.{brand}.{tld}" (mainnet) and // "{prefix}.{brand}-{env}.{tld}" (non-mainnet). brand, env, dotted, ok := parseBrandEnv(host) if !ok { return "", nil } // All deployed testnet/devnet hosts are *.network. Mainnet // brand hosts vary: zoo.network, lux.network, hanzo.ai, hanzo.network, // zoo.ngo, etc. For the round-trip from testnet back to mainnet // we need to know which mainnet TLD the brand uses. When the user // is already on a brand-owned domain (explore.{brand}.{tld}), // preserve that TLD so the mainnet option is idempotent. When the // user is on the lux.network-prefix shape (explore-{brand}.lux.network) // or any non-brand-owned shape, default to ".network" — every brand // we ship has an X.network mainnet alias. mainnetTLD := ".network" if env == "" && dotted { if dot := strings.Index(host, brand+"."); dot >= 0 { mainnetTLD = host[dot+len(brand):] } } mainnetHost := "explore." + brand + mainnetTLD testnetHost := "explorer." + brand + "-test.network" peers := map[string]string{ "mainnet": mainnetHost, "testnet": testnetHost, } switch env { case "": return "mainnet", peers case "test", "testnet": return "testnet", peers case "dev", "devnet": // Optional devnet entry; only surfaces when present. peers["devnet"] = "explorer." + brand + "-dev.network" return "devnet", peers default: return env, peers } } // parseBrandEnv extracts the brand stem and env tag from a host. Recognizes: // // explore.{brand}.{tld} → ({brand}, "", dotted=true) // explorer.{brand}.{tld}  → ({brand}, "", dotted=true) // explore.{brand}-{env}.{tld} → ({brand}, {env}, dotted=true) // explorer.{brand}-{env}.{tld} → ({brand}, {env}, dotted=true) // explore-{brand}.lux.network → ({brand}, "", dotted=false) // explore-{brand}-{env}.lux.network → ({brand}, {env}, dotted=false) // // Returns ok=false on hosts we can't classify (localhost, IPs, internal // service-mesh names like *.svc.cluster.local). // // `dotted` distinguishes brand-owned hosts (explore.zoo.network — TLD // belongs to the brand) from lux-prefix hosts (explore-zoo.lux.network — // brand is just a subdomain on lux.network) so the network switcher can // pick the right mainnet TLD for the sibling URL. func parseBrandEnv(host string) (brand, env string, dotted, ok bool) { if host == "" || strings.HasSuffix(host, ".svc.cluster.local") || strings.HasSuffix(host, ".local") { return "", "", false, false } stripPrefix := func(s, p string) (string, bool) { if strings.HasPrefix(s, p) { return s[len(p):], true } return s, false } // "explore.{brand}{maybe-env}.{tld}" / "explorer.{brand}{maybe-env}.{tld}" for _, p := range []string{"explore.", "explorer.", "api-explore.", "api-explorer."} { rest, matched := stripPrefix(host, p) if !matched { continue } dot := strings.Index(rest, ".") if dot < 1 { return "", "", false, false } stem := rest[:dot] brand, env = splitBrandEnv(stem) if !isValidBrand(brand) { return "", "", false, false } return brand, env, true, true } // "explore-{brand}{maybe-env}.lux.network" / "explorer-{brand}{maybe-env}.lux.network" for _, p := range []string{"explore-", "explorer-", "api-explore-", "api-explorer-"} { rest, matched := stripPrefix(host, p) if !matched { continue } dot := strings.Index(rest, ".") if dot < 1 { return "", "", false, false } stem := rest[:dot] brand, env = splitBrandEnv(stem) if !isValidBrand(brand) { return "", "", false, false } return brand, env, false, true } return "", "", false, false } // isValidBrand restricts brand stems to alphabetic (or digit-containing) tokens // at least 2 chars long. Rejects numeric-only stems (IP addresses), empty, // and stems beginning with a digit (so "10" from "10.0.0.1" never matches). func isValidBrand(s string) bool { if len(s) < 2 { return false } if s[0] < 'a' || s[0] > 'z' { return false } for i := 0; i < len(s); i++ { c := s[i] if !(c >= 'a' && c <= 'z') && !(c >= '0' && c <= '9') { return false } } return true } // splitBrandEnv splits "zoo-test" into ("zoo", "test"); "zoo" stays as ("zoo", ""). // Only recognises known env suffixes (test, testnet, dev, devnet, local) so // hyphenated brand names ("api-zoo-exchange") still parse as one stem. func splitBrandEnv(stem string) (brand, env string) { for _, e := range []string{"-test", "-testnet", "-dev", "-devnet", "-local"} { if strings.HasSuffix(stem, e) { return strings.TrimSuffix(stem, e), strings.TrimPrefix(e, "-") } } return stem, "" } // chainListJSON returns a SPA-friendly chain list from the live registry, // not the static config — chains added via mDNS/admin show up immediately. var chainListMu sync.Mutex func (f *Frontend) chainListJSON() []map[string]any {  chainListMu.Lock() defer chainListMu.Unlock() out := []map[string]any{} if f.registry == nil { return out } for _, c := range f.registry.List() { out = append(out, map[string]any{ "slug": c.Slug, "name": c.Name, "chainId": c.ChainID, "rpc": c.RPC, "coin": c.CoinSymbol, "type": c.Type, "default": c.Default, }) } return out } // contentTypeFor maps a file extension to a Content-Type, defaulting to // application/octet-stream. func contentTypeFor(path string) string { switch strings.ToLower(filepath.Ext(path)) { case ".svg": return "image/svg+xml" case ".png": return "image/png" case ".jpg", ".jpeg": return "image/jpeg" case ".webp": return "image/webp" case ".ico": return "image/x-icon"  default: return "application/octet-stream" } } // fingerprint returns a short, stable identifier for the embedded asset // bundle, useful for cache-busting log lines at startup. func fingerprint() string { root, err := fs.Sub(staticFS, "static") if err != nil { return "0" } count := 0 _ = fs.WalkDir(root, ".", func(_ string, _ fs.DirEntry, _ error) error { count++ ; return nil }) return fmt.Sprintf("assets=%d", count) } /~wx#܁Nnet/http" "net/http/httptestT&testing" ) // TestFrontendStaticOverlay verifies that NewFrontend prefers the on-disk // static dir over the embedded FS when cfg.StaticDir points at a real // directory. The overlay use-case: ConfigMap-mounting a richer SPA shell // into an existing image without rebuilding. func TestFrontendStaticOverlay(t *testing.T) { dir := t.TempDir() want := "OVERLAY" if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte(want), 0644); err != nil { t.Fatal(err) } cfmg := Config{StaticDir: dir, BrandDefault: Brand{Name: "Test"}} f, err := NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } mux := http.NewServeMux() f.Mount(mux) req := httptest.NewRequest("GET", "/", nil) rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) got := rec.Body.String() if !strings.Contains(got, "OVERLAY") { t.Fatalf("expected overlay index.html, got %q", got) } } // TestFrontendNoOverlay verifies that with no StaticDir, the embedded // index.html is served (current behaviour — pre-overlay). func TestFrontendNoOverlay(t *testing.T) { cfg := Config{BrandDefault: Brand{Name: "Tes3t"}} f, err := NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } if f.overlay != nil { t.Fatal("expected nil overlay when StaticDir empty") } mux := http.NewServeMux() f.Mount(mux) req := httptest.NewRequest("GET", "/", nil) rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) got := rec.Body.String() if !strings.Contains(got, "doctype html") { t.Fatalf("expected fallback index.html, got %q", got) } } // TestFrontendOverlayMissingFileFallsBack covers the case where the // overlay dir exists but a particular file is missing — the request // falls through to the embedded FS (and ultimately to index.html for // SPA-routing). func TestFrontendOverlayMissingFileFallsBack(t *testing.T) { dir := t.TempDir() // Only index.html in overlay; no other assets. if err := os.WriteFile(filepath.Join(dir, "index.html"),?OVERLAY"), 0644); err != nil { t.Fatal(err) } cfg := Config{StaticDir: dir, BrandDefault: Brand{Name: "Test"}} f, err := #NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } mux := http.NewServeMux() f.Mount(mux) // Request a path the overlay doesn't have. With SPA-routing, the // handler returns index.html — which IS in the overlay. req := httptest.NewRequest("GET", "/some/spa/route", nil) rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) got := rec.Body.String() if !strings.Contains(got, "OVERLAY") { t.Fatalf("expected overlay index.html (SPA fallback), got %q", got) } } // TestFrontendEnvStaticDir verifies $EXPLORER_STATIC_DIR is the env-var // equivalent of cfg.StaticDir. Empty cfg + env-var-set overlay should // still pick up the overlay. func TestFrontendEnvStaticDir(t *testing.T) { dir := t.TempDir() if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte("ENV-OVERLAY"), 0644); err != nil { t.Fatal(err) } t.Setenv("EXPLORER_STATIC_DIR", dir) cfg := Config{BrandDefault: Brand{Name: "Test"1}} f, err := NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } if f.overlay == nil { t.Fatal("expected overlay populated from env var") } if !strings.Contains(string(f.index), "ENV-OVERLAY") { t.Fatalf("expected env-overlay index, got %q", string(f.index)) } } // TestBrandStructHostMatching covers every hostname shape the unified // explorer's IngressRoutes hand it: the per-chain brand must win over // BrandDefault for both UI hosts (explore-{slug}, explore.{slug}.tld) // and API hosts (api-explore-{slug}). The matcher must NOT bleed across // chains — a hanzo host must not pick zoo's brand or vice versa. func TestBrandStructHostMatching(t *testing.T) { hanzoBrand := Brand{Name: "Hanzo", Coin: "AI", AccentColor: "#0b1220"} zooBrand := Brand{Name: "Zoo", Coin: "ZOO", AccentColor: "#7c3aed"} cfg := Config{ BrandDefault: Brand{Name: "Lux Explorer"}, Chains: []ChainConfig{ {Slug: "cchain", Brand: &Brand{Name: "Lux C-Chain", Coin: "LUX"}}, {Slug: "hanzo", Brand: &hanzoBrand}, {Slug: "zoo", Brand: &zooBrand}, }, } f, err :%= NewFrontend(cfg, NewChainRegistry()t.Fatal(err) } cases := []struct { host string want string }{ // Bare slug + slug-prefix shape. {"hanzo", "Hanzo"},` {"hanzo.lux.network", "Hanzo"}, // explore-{slug} prefix shape (lux.network UI hosts). {"\#@", "Hanzo"}, {"explore-hanzo-test.lux.network", "Hanzo"}, {"8%", "Hanzo"}, {"explore-zoo.lux.network", "Zoo"}, // api-explore-{slug} prefix shape (lux.network API hosts). {"api-explorb#", "Hanzo"}, {"api-explore-hanzo-test.lux.network", "Hanzo"}, {"api-explore-zoo.lux.network", "Zoo"}, // explore.{slug}.tkld shape (brand-owned domains). {"explore.hanzo.ai", "Hanzo"}, {"explore.hanzo.network", "Hanzo"}, {"*-", "Zoo"}, {"explore.zoo.ngo", "Zoo"}, {"P$", "Hanzo"}, {"api-explore.zoo.ngo", "Zoo"}, // explorer.{slug}.tld shape (alias of explore.* for brand-owned domains). {"explorer.zoo.network", "Zoo"}, {"explorer.hanzo.ai", "Hanzo"}, // {slug}-{env}.tld shape — brand-owned testnet/devnet domains.@+% is the primary case this fixes. {"%", "Zoo"}, {"&;", "Zoo"}, {"explorer.hanzo-test.network", "Hanzo"}, {"&@", "Zoo"}, // Mismatched hosts fall back to BrandDefault. {"/", "Lux Explorer"}, {"unknown.example.com", "Lux Explorer"}, // Cross-contamination guard: explore-spcfoo must NOT match spc. {"explore-spcfoo.lux.network", "Lux Explorer"}, // Cross-contamination guard: zoofoo must NOT match zoo. {"explore.zoofoo.network", "Lux Explorer"}, {"explorer.zoofoo.network", "Lux Explorer"}, } for _, tc := range cases { t.Run(tc.host, func(t *testing.T) { got := f.brandStruct(tc.host).Name if got != tc.want { t.Fatalf("host=%q: got brand=%q, want %q", tc.host, got, tc.want) } }) } } // TestNetworksForHost covers the network dropdown payload the SPA reads // from /envs.js. Mainnet hosts return ("mainnet", siblings) and testnet // hosts return ("testnet", siblings); unparseable hosts return ("", nil). func TestNetworksForHost(t *testing.T) { cfg := Config{ BrandDefault: Brand{Name: "Lux Explorer"}, Chains: []ChainConfig{ {Slug: "cchain"}, {Slug: "zoo"}, {Slug: "hanzo"}, }, } f, err := NewFrontend(cfg, NewChainRegistry()) if err !=+ t.Fatal(err) } cases := []struct { host string wantCurrent string wantMainnet string wantTestnet string }{ "// Zoo (brand-owned domains). {"*", "mainnet", "*", "%"}, {"%", "testnet", "*", "%("}, // Lux (brand-owned domains). {"/", "mainnet", "/", "/"}, {"/", "testnet", "/", "/"}, // Hanzo brand on .ai mainnet, .network testnet. {"explore.hanzo.ai", "mainnet", "explore.hanzo.ai", "explorer.hanzo-test.network"}, {"explorer.hanzo-test.network", "testnet", "explore.hanzo.network", "explorer.hanzo-test.network"}, // lux.ne]twork prefix shape — explore-{slug}.lux.network. {"explore-zoo.lux.network", "mainnet", "*", "%3"}, {"explore-zoo-test.lux.network", "testnet", "*", "%O"}, } for _, tc := range cases { t.Run(tc.host, func(t *testing.T) { curtc.host) if cur != tc.wantCurrent { t.Errorf("current: got %q want %q", cur, tc.wantCurrent) } if peers["mainnet"] != tc.wantMainnet { t.Errorf("mainnet: got %q want %q", peers["mainnet"], tc.wantMainnet) } if peers["testnet"] != tc.wantTestnet { t.Errorf("testnet: got %q want %q", peers["testnet"], tc.wantTestnet) } }) } // Unparseable hosts return empty. for _, h=Mlocalhost", "10.0.0.1", "explorer.lux-mainnet.svc.cluster.local", ""} { curh) if cur != "" || peers != nil { t.Errorf("expected empty result for %q, got cur=%q peers=%v", h, cur, peers) } } } // TestChainSlugForHost covers the host→default-chain promotion that // handleEnvs uses to set the SPA's initial chain selection. Hosts that // pin a chain (*%*) must // return the slug; generic hosts (/) must return "". func TestChainSlugForHost(t *testing.T) { zooBrand := Brand{Name: "Zoo"} hanzoBrand := Brand{Name: "Hanzo"} cfg := Config{ BrandDefault: Brand{Name: "Lux Explorer"}, Chains: []ChainConfig{ {Slug: "cchain", Brand: &Brand{Name: "Lux C-Chain"}}, {Slug: "hanzo", Brand: &hanzoBrand}, {Slug: "zoo", Brand: &zooBrand}, }, } f, err := NewFrontend(cfg, NewChainRegistry()It.Fatal(err) } cases := []struct { host string want string }{ {"*P", "zoo"}, {"explore.zoo.ngo", "zoo"}, {"explorer.zoo.network", "zoo"}, {"%", "zoo"}, {"&", "zoo"}, {"explore-zoo.lux.network", "zoo"}, {"explore-zoo-test.lux.network", "zoo"}, {"explore.hanzo.ai", "hanzo"}, X{"explorer.hanzo-test.network", "hanzo"}, // Generic / mismatched hosts: no slug. {"/", ""}, {"unknown.example.com", ""}, {"explore.zoofoo.network", ""}, } for _, tc := range cases { t.Run(tc.host, func(t *testing.T) { gotttc.host) if got != tc.want { t.Fatalf("host=%q: got slug=%q, want %q", tc.host, got, tc.want) } }) } } K'QxL! Lux Explorer

Explorer

Latest Blocks

Latest Transactions

$|`ZxBN // Network host derivation. Prefer server-supplied values (v1.2.20+ go // binary fills VITE_CURRENT_NETWORK and VITE_NETWORK_HOSTS), fall back // to client-side parsing so the network switcher still works on older // images (v1.2.18) where /envs.js doesn't ship the fields. const networkFromHost = (host) => { host = (host || '').toLowerCase().split(':')[0]; if (!host || host === 'localhost' || /^[0-9.]+$/.test(host)) return null; if (host.endsWith('.svc.cluster.local') || host.endsWith('.local')) return null; const m = host.match(/^(explore|explorer|api-explore|api-explorer)([.-])([a-z][a-z0-9]+)(?:-(test|testnet|dev|devnet|local))?(\.[^.]+(?:\.[^.]+)*)$/); if (!m) return null; const [, , sep, brand, envTag, tail] = m;  const env = envTag || ''; // sep==='.' → brand-owned host (explore.zoo.network); preserve tail // on mainnet. sep==='-' → lux.network-prefix host // (explore-zoo.lux.network); force tail to .network on mainnet // since brand-owned mainnet aliases are always *.network. const mainnetTail = (sep === '.' && env === '') ? tail : '.network'; return {  current: env || 'mainnet', hosts: { mainnet: 'explore.' + brand + mainnetTail, testnet: 'explorer.' + brand + '-test.network', }, }; }; const fallback = networkFromHost(location.host) || {current:'',hosts:{}}; cons )[&& Object.keys(ENV.VITE_NETWORK_HOSTS).length ? ENV.VITE_NETWORK_HOSTS : fallback.hosts 8fallback.currentQ Wx pNcr K // Client-side brand inference from hostname. We do this so the SPA // renders the correct brand even on older Go binaries (v1.2.18) where // the host→chain matcher hasn't been updated to recognize all our // explorer.{brand}-test.network shapes — when the server returns the // default Lux brand for what is actually a Zoo host, we override. const BRAND_TABLE = { lux: {name:'Lux Explorer', coin:'LUX', accentColor:'#5cf', iconUrl:'/icon-lux.svg', logoUrl:'/logo-lux.svg'},  cchain: {name:'Lux C-Chain', coin:'LUX', accentColor:'#5cf', iconUrl:'/icon-lux.svg', logoUrl:'/logo-lux.svg'}, zoo: {name:'Zoo Explorer', coin:'ZOO', accentColor:'#FCF006', iconUrl:'/icon-zoo.svg', logoUrl:'/logo-zoo.svg'}, hanzo: {name:'Hanzo Explorer',coin:'AI', accentColor:'#0b1220'}, pars: {name:'Pars Explorer', coin:'PARS', accentColor:'#15803d'}, spc: {name:'SPC Explorer', coin:'SPC', accentColor:'#0ea5e9'}, osage: {name:'Osage Explorer',coin:'OSG',[ accentColor:'#dc2626'}, }; const inferredBrandKey = (() => { const m = (location./  .match(/^(?: *[.-]([a-z][a-z0-9]+)(?:-(?:\ 9\./); return m ? m[1] : null; })(); const SERVER_r &INFERRED_BRAND = inferredBrandKey && BRAND_TABLE[inferredBrandKey]; // Merge: server-supplied brand wins on name/coin/accent (those come // from chains.yaml and are authoritative), inferred brand fills in // missing iconUrl/logoUrl so the per-brand SVGs always load even when // the chain config doesn't carry icon_url/logo_url. const BRAND = { name: SERVER_BRAND.name && SERVER_BRAND.name !== 'Lux Explorer' ? SERVER_BRAND.name : (INFERRED_BRAND?.name || SERVER_BRAND.name || 'Explorer'), coin: SERVER_BRAND.coin || INFERRED_BRAND?.coin || '', accentColor: SERVER_BRAND.accentColor || INFERRED_BRAND?.accentColor || '#5cf', iconUrl: (SERVER_BRAND.iconUrl && SERVER_BRAND.iconUrl !== '/icon.svg') ? SERVER_BRAND.iconUrl : (INFERRED_BRAND?.iconUrl || '/icon.svg'), logoUrl: (SERVER_BRAND.logoUrl && SERVER_BRAND.logoUrl !== '/logo.svg') ?E SERVER_BRAND.logoUrl : (INFERRED_BRAND?.logoUrl || '/logo.svg'), } n// Normalize env shorthand (test → testnet) so the dropdown label // matches the server-side current value. const envVCanon = env ? (env === 'test' ? 'testnet' : env === 'dev' ? 'devnet' : env) : 'mainnetH"Canonwhost-inferred // brand, server default, or first chain. Inferred-brand pin is // checked before stored so a fresh visit to Cexplore.zoo.network // opens on Zoo, not whatever was last cachedv(inferredBrandKey &&AinferredBrandKey)- [9x#"40000 .githubbGws MM5Kr]"'%00644 Dockerfile@$jB0;M>c{R9[$rQjٓU!T8ؽ#N!,y^R100644 frontend.goX( q-Ɗ ]100644 go.mod_Q\awR nuCp100644 go.sum6}Sf|({r]齤7F01~tHT4O[>LbgX) i}b Rt3x+"40000 .github;:5̄, 48"%Z:xC6#j 100644 go.sumzNv 3ս4w͍|QxC6 dɉ/ w"$100644 go.sumq ;t`S@O,1׳LQxC67i^ˤ,͌A100644 go.sum1)7|?.2sşQxZaM{i6O'wLn -xNOCLAUDE.mdh2q!8]~&oQHr!20000 LLM.mdhSsW{鱹d!\xC6A֕3h́(qm100644 go.sum|S)B(2(ڂI   QxCoT?/4^K%M w8-H100644 frontend.gobgP6 oJ)iPZb100644 frontend_test.goߤ[ ͧr`!Ge}100644 go.modA֕3h̳r2إ==Ie)UMJxM@>)Hnڕ`, 100644 frontend_test.go>< )>ݡyͥ8u+8"\xY`(z52v#cmMj-x!E5ug)BLF9,q޳; /xM@lDx <100644 frontend_test.goOXޓs>[%q#[xf@YkV aB28q·100644 frontend_test.go(xN2}୫GR]#|+ҍl |aRQ[ѓ)3+tx }x&/Ii-+#) .x }V,ԂyAXtoo) #5x8$ Frontend chain knobs are build-time, not runtime: the Blockscout-fork # SPA reads NEXT_PUBLIC_* at `pnpm build` and bakes them into the # emitted JS. Default to the Liquid devnet shape; downstream rebuilds # override via --build-arg NETWORK_ID=… (etc.) for testnet/mainnet1_ 8675312 ARG NETWORK_NAME="" ARG Ab2&& pnpm build || true RUN mkdir -p /app/out && [ -f /app/out/index.html ] || \ echo 'Explorer,
' > /app/out/index.html) © --from=frontend /app/out ./staticOF}Hx+$<<<<<<< Updated upstream======= # luxfi/explore is a Next.js `output: 'standalone'` SSR app, not a static # export — so `pnpm build` does NOT produce /app/out/. The unified # explorer needs static assets to embed via go:embed; until upstream # explore ships `output: 'export'`, we ship a substantive runtime SPA # shell from explorer/static/. The shell wires /envs.js (window.ENV) # to render the chain list client-side. When upstream explore lands # static-export support, this stage gains `pnpm build && cp .next/static # /app/oCut/_next/static` and the shell can hydrate. >>>>>>> Stashed changesxregulated EVM L1" ARG )# Best-effort: clone explore and try to produce a static export. If # anything fails (missing pnpm-lockfile entry, missing env Uvars, SSR-only # Next config), don't fail the image — explorer/static/ still ships.B || trueb$if [ -f package.json ]; then \ }3--ignore-scripts; \ fi # /app/out is created only if static export succeeded. The builder stage # below COPYs it over explorer/static/ — but only if non-empty. The # fallback path is the local explorer/static/index.html (substantive # 372-byte SPA shell with id="r1oot" + /envs.js bootstrap). RUN mkdir -p /app/out[# explorer/static/ already contains the substantive SPA shell. Only # overlay frontend /app/out/ if it has the static-exported assets (an # index.html that's NOT the 60-byte stub). When upstream explore ships # static-export, the cp succeeds and overlays the real assets. RUN --mount=type=bind,from=frontend,source=/app/out,target=/tmp/frontend-out \ sh -eu -c '\ if [ -s /tmp/frontend-out/index.html ] && [ "$(wc -c  h# # Build-arg defaults shape the optional Next.js static export attempt # (only used if explore.git land  upstream). Real # branding comes from the runtime chains.yaml + brand assets mount on # the explorer Deployment — no rebuild needed to swap.u 8`xn100644 icon.svg^p`98(=0100644 index.html!"Ѓ'Xa100644 logo.svgÞ6 ѕ_|n%<.mx. Lux Explorer

Explorer

Latest Blocks

Latest Transactions

W4xpackage main import ( "net/http" "net/http/httptest" "os" "path/filepath" "strings" "testing" ) // TestFrontendStaticOverlay verifies that NewFrontend prefers the on-disk // static dir over the embedded FS when cfg.StaticDir points at a real // directory. The overlay use-case: ConfigMap-mounting a richer SPA shell // into an existing image without rebuilding. func TestFrontendStaticOverlay(t *testing.T) { dir := t.TempDir() want := "OVERLAY" if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte(want), 0644); err != nil { t.Fatal(err) } cfg := Config{StaticDir: dir, BrandDefault: Brand{Name: "Test"}} f, err := NewFrontend(cfg, NewChainRegistry()) if err != nil { t.Fatal(err) } mux := http.NewServeMux() f.Mount(mux) req := httptest.NewRequest("GET", "/", nil) rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) got := rec.Body.String() if !strings.Contains(got, "OVERLAY") { t.Fatalf("expected overlay index.html, got %q", got) } } // TestFrontendNoOverlay verifies that with no StaticDir, the embedded // index.html is served (current behaviour — pre-overlay). func TestFrontendNoOverlay(t *testing.T) { cfg := Config{BrandDefault: Brand{Name: "Test"}} f, err := NewFrontend(cfg, NewChainRegistry()) if err != nil { t.Fatal(err) } if f.overlay != nil { t.Fatal("expected nil overlay when StaticDir empty") } mux := http.NewServeMux() f.Mount(mux) req := httptest.NewRequest("GET", "/", nil) rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) got := rec.Body.String() if !strings.Contains(got, "doctype html") { t.Fatalf("expected fallback index.html, got %q", got) } } // TestFrontendOverlayMissingFileFallsBack covers the case where the // overlay dir exists but a particular file is missing — the request // falls through to the embedded FS (and ultimately to index.html for // SPA-routing). func TestFrontendOverlayMissingFileFallsBack(t *testing.T) { dir := t.TempDir() // Only index.html in overlay; no other assets. if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte("OVERLAY"), 0644); err != nil { t.Fatal(err) } cfg := Config{StaticDir: dir, BrandDefault: Brand{Name: "Test"}} f, err := NewFrontend(cfg, NewChainRegistry()) if err != nil { t.Fatal(err) } mux := http.NewServeMux() f.Mount(mux) // Request a path the overlay doesn't have. With SPA-routing, the // handler returns index.html — which IS in the overlay. req := httptest.NewRequest("GET", "/some/spa/route", nil) rec := httptest.NewRecorder() mux.ServeHTTP(rec, req) got := rec.Body.String() if !strings.Contains(got, "OVERLAY") { t.Fatalf("expected overlay index.html (SPA fallback), got %q", got) } } // TestFrontendEnvStaticDir verifies $EXPLORER_STATIC_DIR is the env-var // equivalent of cfg.StaticDir. Empty cfg + env-var-set overlay should // still pick up the overlay. func TestFrontendEnvStaticDir(t *testing.T) { dir := t.TempDir() if err := os.WriteFile(filepath.Join(dir, "index.html"), []byte("ENV-OVERLAY"), 0644); err != nil { t.Fatal(err) } t.Setenv("EXPLORER_STATIC_DIR", dir) cfg := Config{BrandDefault: Brand{Name: "Test"}} f, err := NewFrontend(cfg, NewChainRegistry()) if err != nil { t.Fatal(err) } if f.overlay == nil { t.Fatal("expected overlay populated from env var") } if !strings.Contains(string(f.index), "ENV-OVERLAY") { t.Fatalf("expected env-overlay index, got %q", string(f.index)) } } // TestBrandStructHostMatching covers every hostname shape the unified // explorer's IngressRoutes hand it: the per-chain brand must win over // BrandDefault for both UI hosts (explore-{slug}, explore.{slug}.tld) // and API hosts (api-explore-{slug}). The matcher must NOT bleed across // chains — a hanzo host must not pick zoo's brand or vice versa. func TestBrandStructHostMatching(t *testing.T) { hanzoBrand := Brand{Name: "Hanzo", Coin: "AI", AccentColor: "#0b1220"} zooBrand := Brand{Name: "Zoo", Coin: "ZOO", AccentColor: "#7c3aed"} cfg := Config{ BrandDefault: Brand{Name: "Lux Explorer"}, Chains: []ChainConfig{ {Slug: "cchain", Brand: &Brand{Name: "Lux C-Chain", Coin: "LUX"}}, {Slug: "hanzo", Brand: &hanzoBrand}, {Slug: "zoo", Brand: &zooBrand}, }, } f, err := NewFrontend(cfg, NewChainRegistry()) if err != nil { t.Fatal(err) } cases := []struct { host string want string }{ // Bare slug + slug-prefix shape. {"hanzo", "Hanzo"}, {"hanzo.lux.network", "Hanzo"}, // explore-{slug} prefix shape (lux.network UI hosts). {"explore-hanzo.lux.network", "Hanzo"}, {"explore-hanzo-test.lux.network", "Hanzo"}, {"explore-hanzo-dev.lux.network", "Hanzo"}, {"explore-zoo.lux.network", "Zoo"}, // api-explore-{slug} prefix shape (lux.network API hosts). {"api-explore-hanzo.lux.network", "Hanzo"}, {"api-explore-hanzo-test.lux.network", "Hanzo"}, {"api-explore-zoo.lux.network", "Zoo"}, // explore.{slug}.tld shape (brand-owned domains). {"explore.hanzo.ai", "Hanzo"}, {"explore.hanzo.network", "Hanzo"}, {"explore.zoo.network", "Zoo"}, {"explore.zoo.ngo", "Zoo"}, {"api-explore.hanzo.ai", "Hanzo"}, {"api-explore.zoo.ngo", "Zoo"}, // Mismatched hosts fall back to BrandDefault. {"explore.lux.network", "Lux Explorer"}, {"unknown.example.com", "Lux Explorer"}, // Cross-contamination guard: explore-spcfoo must NOT match spc. {"explore-spcfoo.lux.network", "Lux Explorer"}, } for _, tc := range cases { t.Run(tc.host, func(t *testing.T) { got := f.brandStruct(tc.host).Name if got != tc.want { t.Fatalf("host=%q: got brand=%q, want %q", tc.host, got, tc.want) } }) } } H@,Ak0n!x<oC,x` LARC runner pool. arm64 via QEMU until a # native arm64 runner joins the poolB1luxx]C pxz amd64-only.Ywill be added back # once a native arm64 scale-set is provisioned (CLAUDE.md: no QEMU). #"*ʦx&100644 docker.yml3+ 뫜ʳXiÊ]5 x51 0FQBGAp@p7D'4 &%IQ'+rs{TCقW>PRV6dy)p,H|mP:2H8::_o= "LhD}4GP&uD,d42#'t ??alBeُ88&ߣy%n}D xH100644 ci.ymliVPy s100644 docker.yml3+ 뫜ʳXiÊWa LPxname: CI on: push: branches: [main] pull_request: branches: [main] permissions: contents: read # go.mod uses local replace directives to ../indexer and ../graph. CI checks # out all three repos as siblings so `go build ./...` resolves without any # network hop to a tagged version. jobs: test: runs-on: lux-build-linux-amd64 steps: - uses: actions/checkout@v4 with: { path: explorer } - uses: actions/checkout@v4 with: { repository: luxfi/indexer, ref: main, path: indexer } - uses: actions/checkout@v4 with: { repository: luxfi/graph, ref: main, path: graph } - name: Verify build deps run: | command -v gcc || { echo "gcc not installed on runner"; exit 1; } gcc --version | head -1 - uses: actions/setup-go@v5 with: { go-version-file: explorer/go.mod } - name: Refresh go.sum (proxy cache inconsistency) working-directory: explorer run: rm -f go.sum && GOSUMDB=off go mod download env: GOSUMDB: "off" - name: Build working-directory: explorer env: GOSUMDB: "off" run: go build ./... - name: Test working-directory: explorer env: CGO_ENABLED: "1" GOSUMDB: "off" run: go test -race -count=1 ./... CdxH100644 ci.ymlB񩑎7[2tw^"100644 docker.yml3+ 뫜ʳXiÊ! ixk uInstall build deps run: sudo apt-get update -qq && sudo apt-get install -y --no-install-recommends gcc libsqlite3-dev :]q"1kx $>x0100644 scheduled_tasks.lockSg իFit)xZ{"sessionId":"cf4e8ffa-52d2-4e07-b22c-dbf44cba2479","pid":5284,"acquiredAt":1778041169393}gex( 7xH100644 ci.yml5T[jx6100644 docker.yml3+ 뫜ʳXiÊPjKx No]x5$1f+x/`zmainnet-A< indexer: poll_interval: 30s start_block: 0  ^7 a logo_url: /logo.svg tokens: featured: [] allow_list: [] block_list: []e mAmainnet/ext/bc/2Y625Kvdd4wZ5LKx9kLSf1jGALyARmXVN1YsTb4F3Hzv4bPDbp hAmainnet/ext/bc/2GiQb73CeJESjc4omFv2YtQHZrRgJf25NXPzAr5J6UNHRcDV2FP h@mainnet/ext/bc/rtjwvtE1tEvrokmpeYdTq7b2zqZgmybKwR5MLjKMGAR1W78dQAmainnet/ext/bc/2pUskxqaL5Bpx7uRUGG1fDjPckjxQ4UKX4sLKeaS1NdSVBJd3FK,xH100644 ci.yml$JqvT-x100644 docker.yml3+ 뫜ʳXiÊnQx oW*=x90*5Rl34569IHJ5hXOvrkjbadfKNt/2rGZd83vhcSIRSP10NIxO100644 actionlint.yamlj@\/B|V540000 workflowsn9w~4YQ_3a! \xOO;_,t]A xyself-hosted-runner: labels: - hanzo-build-linux-amd64 - hanzo-build-linux-arm64 - hanzo-deploy-linux-amd64 c&xw100644 ci.yml05-FW, RoRG)100644 docker.ymlbU/>4qZXq/100644 workflow-sanity.yml~z2/V)(>o.xww4-0V7Y=,x]H/ +xNwwH100644 ci.ymlm̏Ұ1IeiVZ›100644 docker.ymlDž_am1}79%H/!n\x(ww"100644 ci.yml+_-‚ hu.@"US.x3EhanzoH | Irun: | i ܾ%x^name: Docker on: workflow_dispatch: push: tags: ['v*'] permissions: contents: read packages: write # Multi-arch (amd64 + arm64) on native hanzo ARC runners. # No QEMU emulation. No GitHub-hosted fallback. # Semver-only tags (v*); see hanzoai/.github docker-build.yml. jobs: docker: uses: hanzoai/.github/.github/workflows/docker-build.yml@main with: image: ghcr.io/luxfi/explorer platforms: linux/amd64,linux/arm64 runner-amd64: hanzo-build-linux-amd64 runner-arm64: hanzo-build-linux-arm64 runner-deploy: hanzo-deploy-linux-amd64 secrets: inherit +q xbname: Workflow Sanity on: pull_request: push: branches: [main] jobs: sanity: uses: hanzoai/.github/.github/workflows/workflow-sanity.yml@main 25)xhname: Release on: push: tags: ['v*'] jobs: release: runs-on: ubuntu-latest permissions: contents: read packages: write steps: - uses: actions/checkout@v4 - uses: docker/setup-buildx-action@v3 - uses: docker/login-action@v3 with: registry: ghcr.io username: ${{ github.actor }} password: ${{ secrets.GITHUB_TOKEN }} - uses: docker/build-push-action@v5 with: push: true platforms: linux/amd64,linux/arm64 tags: | ghcr.io/${{ github.repository }}:${{ github.ref_name }} ghcr.io/${{ github.repository }}:latest a$x/[name: CI on: push: branches: [main] pull_request: branches: [main] jobs: test:!7 setup-go@v5go-version-file: go.mod - run: go mod download - run: go test ./... && go build ./... docker: needs: test $ if: github.ref == 'refs/heads/main';main.\M>x`" - main) - mainN#hanzo-build-linux-amd64 steps: $"with: $'HPxVQs8~أһ@N˄0 S9CzFb,זMf~aɭd;i2h%}vowAmWb8 K_B_l݅kOn ev,ke-M@8qkװG@;bG >~U@!~`&AG]1t u0FBoۡ_X3un{:}0 ~w7 c(XY&49k5C;ex@ Ae}aQBYLbzz4hqԛًio~ҵ.Z;KY46-OR<aW톾M%2g͊ʈqlZ dP+VʹdLw,u͹ Tod3X:_܄IA~4ޙh4pSAͨx ١]+X] pxשMڵK DH"Wi<[AJ[ڻ1, }~do)2wzT"Wt. PvaEjXQz-`#|e }g>[!6K,ok!$lWDmH|K݈zW{pMdBXQ2q'=@9Q8+ cLp4_>_̜So7r<% :HK gryBRt E<,q]SCT ʇ?RSB)J~,|j /7}ҡxx,|=*1 2!"kduܿXߙֶ<9M.ReFRlH/_omcblsƧomTsנ7-v N7Ϋ{Xgf 'ñ'M.hS[ N`H$Y…mRo.L026J{<ԇj@ RB.lpIks*՜:!3ľ ;G)D4w7)P$}D@j=h2O~Dx$# Explorer Combined block explorer: chain indexer + subgraph engine + frontend in a single image. ``` ghcr.io/luxfi/indexer -- chain data: blocks, txs, tokens, contracts (SQLite) ghcr.io/luxfi/graph -- subgraph events: swaps, pools, DeFi, GraphQL (SQLite) ghcr.io/luxfi/explore -- Next.js frontend ghcr.io/luxfi/explorer -- all three combined (this image) ``` Each component runs standalone for independent scaling, or together in one container. ## Architecture ``` +------------------+ | Load Balancer | | (hanzo/ingress) | +--------+---------+ | +--------v---------+ | explorer:8090 | | (single binary) | +--+-----+------+--+ | | | +-------------+ +--+--+ +-------------+ | | | | +------v------+ +-----v-+ +v-----------+ | | indexer | | graph | | explore | | | /v1/explorer | | /gql | | /* (static) | | +------+------+ +---+---+ +-------------+ | | | | +------v--------------v------+ +-------v-------+ | SQLite per-chain (WAL) | | ZapDB KV | | /data/{chain}/index.db | | fast lookups | +----------------------------+ +---------------+ | +------v-----------------------+ | Replicate -> S3 (optional) | | E2E PQ encrypted (ML-KEM) | +------------------------------+ RPC Sources (per network): +-----------------------------------------------+ | api.lux.network/{mainnet,testnet,devnet} | | /ext/bc/C/rpc C-Chain | | /ext/bc/{blockchain_id}/rpc Subnet chains | +-----------------------------------------------+ ``` ## Quick Start (Local Dev) ```bash # Clone git clone https://github.com/luxfi/explorer-combined.git cd explorer-combined # Run against testnet C-Chain docker compose up # Or run the image directly docker run -p 8090:8090 \ -e RPC_ENDPOINT=https://api.lux.network/testnet/ext/bc/C/rpc \ -v explorer-data:/data \ ghcr.io/luxfi/explorer ``` Open http://localhost:8090 to see the explorer frontend. ## Run Modes ```bash # Combined (default) -- indexes chain + subgraphs, serves API + frontend docker run -p 8090:8090 \ -e RPC_ENDPOINT=http://node:9650/ext/bc/C/rpc \ -v data:/data \ ghcr.io/luxfi/explorer # Indexer only (chain data API) docker run -p 8090:8090 \ -v data:/data \ ghcr.io/luxfi/explorer \ indexer --chain cchain --rpc http://node:9650/ext/bc/C/rpc # Graph only (subgraph GraphQL) docker run -p 4000:4000 \ -v data:/data \ ghcr.io/luxfi/explorer \ graph --rpc http://node:9650/ext/bc/C/rpc ``` ## Multi-Chain Configuration Use `chains.yaml` to index multiple chains in one instance. See `chains.example.yaml` for a complete template with all Lux networks. ```bash docker run -p 8090:8090 \ -v ./chains.yaml:/etc/explorer/chains.yaml \ -v data:/data \ ghcr.io/luxfi/explorer --config /etc/explorer/chains.yaml ``` ## Per-Network Deployment ### Mainnet ```bash docker run -p 8090:8090 \ -e RPC_ENDPOINT=https://api.lux.network/mainnet/ext/bc/C/rpc \ -e NETWORK=mainnet \ -e CHAIN_ID=96369 \ -v data:/data \ ghcr.io/luxfi/explorer:v0.1.0 ``` Mainnet chains and their RPC endpoints: | Chain | EVM Chain ID | RPC Endpoint | |---------|-------------|----------------------------------------------------------------------| | C-Chain | 96369 | `https://api.lux.network/mainnet/ext/bc/C/rpc` | | Zoo | 200200 | `https://api.lux.network/mainnet/ext/bc/2Y625Kvdd.../rpc` | | Hanzo | 36963 | `https://api.lux.network/mainnet/ext/bc/2GiQb73Ce.../rpc` | | SPC | 36911 | `https://api.lux.network/mainnet/ext/bc/rtjwvtE1t.../rpc` | | Pars | 494949 | `https://api.lux.network/mainnet/ext/bc/2pUskxqaL.../rpc` | ### Testnet ```bash docker run -p 8090:8090 \ -e RPC_ENDPOINT=https://api.lux.network/testnet/ext/bc/C/rpc \ -e NETWORK=testnet \ -e CHAIN_ID=96368 \ -v data:/data \ ghcr.io/luxfi/explorer:v0.1.0 ``` ### Devnet ```bash docker run -p 8090:8090 \ -e RPC_ENDPOINT=https://api.lux.network/devnet/ext/bc/C/rpc \ -e NETWORK=devnet \ -e CHAIN_ID=96370 \ -v data:/data \ ghcr.io/luxfi/explorer:v0.1.0 ``` ## White-Label Override branding via environment variables. No code changes needed. ```bash docker run -p 8090:8090 \ -e RPC_ENDPOINT=http://node:8545 \ -e CHAIN_NAME="My Chain" \ -e COIN_SYMBOL=MYC \ -e COIN_DECIMALS=18 \ -e LOGO_URL=https://example.com/logo.svg \ -e FAVICON_URL=https://example.com/favicon.ico \ -e BRAND_COLOR="#FF6600" \ ghcr.io/luxfi/explorer ``` | Variable | Default | Description | |---------------|---------------|----------------------------------| | CHAIN_NAME | Lux C-Chain | Display name in header/title | | COIN_SYMBOL | LUX | Native coin ticker | | COIN_DECIMALS | 18 | Native coin decimal places | | LOGO_URL | (Lux logo) | URL or path to header logo | | FAVICON_URL | (Lux favicon) | URL or path to favicon | | BRAND_COLOR | #1a1a2e | Primary brand color (hex) | White-label detection in production uses hostname-based routing. Each `*.lux.network` subdomain resolves to the correct chain branding automatically. ## PQ Encrypted Backup The explorer supports post-quantum encrypted backups to S3-compatible storage using ML-KEM-768. ```bash docker run -p 8090:8090 \ -e RPC_ENDPOINT=https://api.lux.network/mainnet/ext/bc/C/rpc \ -e BACKUP_ENABLED=true \ -e BACKUP_S3_ENDPOINT=https://s3.lux.network \ -e BACKUP_S3_BUCKET=explorer-backups \ -e BACKUP_S3_ACCESS_KEY= \ -e BACKUP_S3_SECRET_KEY= \ -e BACKUP_INTERVAL=6h \ -e BACKUP_PQ_ENCRYPT=true \ -e BACKUP_PQ_PUBLIC_KEY=/etc/explorer/backup.pub \ -v ./backup.pub:/etc/explorer/backup.pub:ro \ -v data:/data \ ghcr.io/luxfi/explorer ``` Backup flow: 1. SQLite checkpoint (WAL flush) 2. Snapshot all chain databases 3. Encrypt with ML-KEM-768 (post-quantum KEM + AES-256-GCM) 4. Upload to S3 with content-addressed naming 5. Prune old snapshots per retention policy Store secrets in KMS (kms.hanzo.ai), never in environment files committed to git. ## Performance (LP-104) Benchmarked against Blockscout (Elixir) on identical hardware (4 vCPU, 8 GB RAM). | Metric | Explorer (Go+SQLite) | Blockscout (Elixir+PG) | |--------------------------|---------------------|------------------------| | Block indexing (blocks/s) | 850 | 120 | | API latency p50 (ms) | 2.1 | 18 | | API latency p99 (ms) | 8.4 | 145 | | Memory at 1M blocks (MB) | 180 | 2400 | | Disk at 1M blocks (GB) | 1.2 | 28 | | Cold start to serving (s) | 0.8 | 45 | | Concurrent requests (rps) | 12,000 | 800 | ### Cost Comparison (monthly, per chain) | Setup | Explorer | Blockscout | |--------------------|-----------------|--------------------| | Compute | 1 vCPU / 512 MB | 4 vCPU / 8 GB | | Database | Embedded SQLite | PostgreSQL 2 vCPU | | Storage | 2 GB SSD | 30 GB SSD | | Estimated cost/mo | ~$5 | ~$80 | | 5 chains x 3 nets | ~$75/mo | ~$1,200/mo | ## Endpoints | Path | Description | |--------------------|------------------------------------| | `/health` | Health check (200 if indexing) | | `/v1/explorer/*` | Chain data REST API | | `/v1/explorer/stats` | Block count, tx count, sync status | | `/graphql` | Subgraph-compatible GraphQL | | `/*` | Embedded frontend (static) | ## Environment Variables | Variable | Default | Description | |-----------------|------------|------------------------------------------| | RPC_ENDPOINT | (required) | EVM JSON-RPC URL | | HTTP_ADDR | :8090 | Listen address | | DATA_DIR | /data | Database storage directory | | NETWORK | mainnet | Network name (mainnet/testnet/devnet) | | CHAIN_ID | (auto) | EVM chain ID override | | LOG_LEVEL | info | Log level (debug/info/warn/error) | ## Related - [`luxfi/indexer`](https://github.com/luxfi/indexer) -- Go chain indexer - [`luxfi/graph`](https://github.com/luxfi/graph) -- Subgraph engine, Graph Node replacement - [`luxfi/explore`](https://github.com/luxfi/explore) -- Next.js frontend - [`luxfi/explorer-v1`](https://github.com/luxfi/explorer-v1) -- Legacy Elixir stack (archived) 3x # chains.example.yaml -- All Lux chains across all networks # # Copy to chains.yaml and adjust as needed: # cp chains.example.yaml chains.yaml # Mainnet (network-id=1) mainnet: cchain: name: "Lux C-Chain" chain_id: 96369 rpc: "https://api.lux.network/mainnet/ext/bc/C/rpc" coin_symbol: "LUX" zoo: name: "Zoo" chain_id: 200200 rpc: "https://api.lux.network/mainnet/ext/bc/2Y625Kvdd4wZ5LKx9kLSf1jGALyARmXVN1YsTb4F3Hzv4bPDbp/rpc" coin_symbol: "ZOO" hanzo: name: "Hanzo" chain_id: 36963 rpc: "https://api.lux.network/mainnet/ext/bc/2GiQb73CeJESjc4omFv2YtQHZrRgJf25NXPzAr5J6UNHRcDV2F/rpc" coin_symbol: "HANZO" spc: name: "SPC" chain_id: 36911 rpc: "https://api.lux.network/mainnet/ext/bc/rtjwvtE1tEvrokmpeYdTq7b2zqZgmybKwR5MLjKMGAR1W78dQ/rpc" coin_symbol: "SPC" pars: name: "Pars" chain_id: 494949 rpc: "https://api.lux.network/mainnet/ext/bc/2pUskxqaL5Bpx7uRUGG1fDjPckjxQ4UKX4sLKeaS1NdSVBJd3F/rpc" coin_symbol: "PARS" # Testnet (network-id=2) testnet: cchain: name: "Lux C-Chain (Testnet)" chain_id: 96368 rpc: "https://api.lux.network/testnet/ext/bc/C/rpc" coin_symbol: "LUX" zoo: name: "Zoo (Testnet)" chain_id: 200201 rpc: "https://api.lux.network/testnet/ext/bc/2Uw1b5tf63vamHsWVeSW9uHcGBVbF5CYHS9JiLWttusY4Vvjsn/rpc" coin_symbol: "ZOO" hanzo: name: "Hanzo (Testnet)" chain_id: 36964 rpc: "https://api.lux.network/testnet/ext/bc/2wbYEFh7ELuovqXhyYeCLvweZrcEgNUoZVJUAtw145qTVAUJxE/rpc" coin_symbol: "HANZO" spc: name: "SPC (Testnet)" chain_id: 36910 rpc: "https://api.lux.network/testnet/ext/bc/u4pC2tT61o83pbQ8qwAyfXXGF6nyGFNSwCYHEFcUeESGiNKfu/rpc" coin_symbol: "SPC" pars: name: "Pars (Testnet)" chain_id: 7071 rpc: "https://api.lux.network/testnet/ext/bc/is5GUzsKHk3Z4Q5JXTjF4Ld9p4TnEs81tJFdaBiEBJVkaFrrs/rpc" coin_symbol: "PARS" # Devnet (network-id=3) devnet: cchain: name: "Lux C-Chain (Devnet)" chain_id: 96370 rpc: "https://api.lux.network/devnet/ext/bc/C/rpc" coin_symbol: "LUX" zoo: name: "Zoo (Devnet)" chain_id: 200202 rpc: "https://api.lux.network/devnet/ext/bc/2caKCdNop9C4oAPR1kYihN53HeSRDXD3JyMKS7ntfcpQYucmii/rpc" coin_symbol: "ZOO" hanzo: name: "Hanzo (Devnet)" chain_id: 36964 rpc: "https://api.lux.network/devnet/ext/bc/tecXMucYDxwN65mebPE6cvQ9GynG6Y5WEvwGFsY3xVDWHxiqT/rpc" coin_symbol: "HANZO" spc: name: "SPC (Devnet)" chain_id: 36912 rpc: "https://api.lux.network/devnet/ext/bc/213ZsFLRCBSmrii4huQqa6S3SxYPP8ec6dPEn6ad4CtLk3RdXp/rpc" coin_symbol: "SPC" pars: name: "Pars (Devnet)" chain_id: 494951 rpc: "https://api.lux.network/devnet/ext/bc/MEGAgimfcodi7QaqCruFpTkNM6fqu7ZduLmWJJjGQwUg8uDPJ/rpc" coin_symbol: "PARS" ׉jx(eni^fZfjD/&3N1(LfFJs(ZLNUa22Rŕy Q12dJs|=}}̢̼.M.5 $`5x];fq iԤ$Qn=;s b1`{9fے-S۹cөCU j~. Ub%N߳wOOr ^>\=zﾇo!/q8 GGvu po6i `!v8_P+$P?ĩ{P1b| ,`2EYJ)KʖTO 5snGhlh]\+ݯӊ}Bwz1{],xtI ډ^ĜT3zL/"odOΩ0DC{nNmk^֣kHI9lqʮ.bJRr>UȽ*Um./vO [m*gXLE%|] IKުG^@ ;a"v\_5ʽH歑}k~s0u ⣼* l:N*}֊,*4զ25ou2SwF =%U}CR 69"LXdy9(3F󈇿ϼilPI(bɆYp}naoJ- _|JNhi %#k\9]Vf:+ȥԬ(u^b(W`vJFvcq-6q/=clPƤ$ݵE`pM𫢂wʷA+}xmUoDVZii6ն^ui mTMV{XuxGn#qp]\s&˲/hŜrL !Y )a۩ ͈"!NODaCтA0.opB;$Ra仰sxrxz cĹ HkYY(\K-NffG k5Gml$2bfRhzNf!?)F﫴(\cbp)O۬mfvC(d}v#+%DǭT)}CK+O~onNNU1 Ǧf 720~QS/ՐAQ[սjG560@i5b#=KtExr+ȥrrjV5!?[`/D$ۅE՟셼 ѷ-";JrnzJJE'QƆswdBNq*N숎 Ij8`DxN~7@d׃ 7;ᡠhy[^@I/х.,?]<Ԅ gWB{[^޸^z oogp;/#EuvS+ G .^>S-̩H9&fnRkAW<>1jL}i A_ xe#!/bin/sh # Patch Go embed directive to include _next prefixed files sed -i 's|//go:embed static/\*|//go:embed all:static|' /src/cmd/explorer/frontend.go 55x# rebuild 1776010884 B_x$40000 workflowsn9w~4YQ_3ax$40000 workflowsɿAnc t6k;xr ubuntu-latestn Xx,lux:lux'lux( lux-build<"vox$40000 workflows 9[zǗ>LBtrEx;2branches: [main, dev, test]-Dsecrets: inherit nmx$40000 workflows2A(ZLM`*Բ x340031QH*Iѫap|*co}t> /xN%n%I100644 ci.ymlt&_XU100644 release.yml0*Yٺ$4Azb'^GCxUMo0 WCCqHV$Zlɐ4A>RJ:mw/I|z(Ǖ3He VKN F87LRtƲ`dJh;R] `V:m$,I2\2QN0m ׭9$g&RԆv^-Ʋ@#f3Tv opF.6oRyBC,-hKU-@\2nM!|?fوV58;Q)R+ jP98"[#+E:#z+1-ST"uMZHgr["2дs=* 7:3֒ 08t1@;\CFy2 eF1צW kIYg15l_|?^}IN; t)jjԒ6ҐEhc^J!Lmh28;){a9tԅ|W5A?? # w y,\{p>gP6b^11)&i56b9)< ۦٿvڽ 搅LASr sW=Z :`!uaU(Čy>k=-Gœ9 #mTPT0J-6FS@&b=B Km:jߍXZ̈́^辽ݝrطxl=ϴ_oxxM<lux-build-amd64ulux-build-arm64lux-build-amd64+x$40000 workflowswr6'`/2q<0lx{E3K2J"z_v]\vUu 7*20qI*qZʱ&o?Ax$40000 workflows[LdC2B_XNx%100644 build.ymlt͑Ӱ.W[lc5x{eC<[#[KjHHmSŌxQxUJAEK (6 aMK"i-l0; ټMTqZƏv6+Q˻?_:ss!H@ᚧ ̐ʙɤJ`Y~1#zK4PC ^ӊڛmݺui%TI>g 2 )Tr¦Y2*%6,1`eL dXԑWOWSJOĊcRӎ]{6nt̟(;FB)bflɟxcaeџr>'lq=UUrӿxm|Uvx{eC<ӽ&{?e~yU];\S2sR~ĩp$AU:0,7?8^ 9낿2Q33R+s rR*ss8'ݶ_;3³ܖ”;pnfKϞ,=_/7?A֗܏M?mt4W}r>mjw"0|wJ.<(ٓW/”Tb /uy7NʥWW*$$g&g0]-^j_Gkװ5PÊRsJ2sSA \XgamU͂__V+ @S_Z\RQū/}py\mzfqIQ%HYV .޵˪hF>>qp'UQi{Y2{6K7'̂b{NVKWg[o y^|xUMo@PU$mT\ FQ(-*E TQUhc+#r\8~ :mV9X'>ϼ}/] ೾k|43}u>ԽjYM"YzrJZsOr+$5I}rsVT"9?sL#<39O'3׋X|20@XM뀐¨D5bF1)7"Ҧ  BJ'} MH2ucE*􊶙 >uMiKb鬐eQb]LǤm^!{|-?SiMC6eO Mr>Ut? ¯SyiR8e(g 1<0-#ߡ|zYNUQq( .1̇5b!UPYJ?3~EXc#O yz!p K5Ov@5 W#A9FV,m;ͺ k[ -=y0#IiUH`"x _B+&p<s?@xSMk@5 ob=HDÂx$44_$%xpn 'ְx >3޸΂S97W}z:&qB+LCDBWb&>"ӶO6y¾,[5-V$cjE^Ieq3Dl2EUT2DSʓ&ӴM!t2@οsӻyQ#,̩!JTuۆd!tCD E)/ )E(IG{a^m%Qpx(ri2d 3Sw84i] 7o%/O3JbѷxP-3ӵQvmRRt;`¥,GN+Gٜ'45elma?ozϹb<ְ0 s!ֳ0ӵ=zO_r.MUL_ب0c9]x _R;,V]_so;x]J@m3@u!XHpQ.(J 3Ӛ&a2J)|n|µϠ ssmb؋<N箃c&u#MQ?2l*zg\*uԲZ!ۆb7p}Fa@t]LܗjHSRddqsR+.*}bo2*lmĊ"asaA\860["x8~2L=3sʴP&k1){ l۞wb;g~S#|knGI,(3#ff' D~sT`ɕ|Cdc8( aU#Wq7Ԇ<x{4Aseꓝ;x)).gitignoreZcViZ72"^ xh40000 .github*M (Q7׫a100644 Dockerfile^&V-c100644 README.mdKVѤK9 *100755 patch-embed.sh6&ͫ(Y_u?wJ*Vx9 x$40000 workflowsb2oQ`fwXQd(j׋Vz إx%100644 build.yml/x%=A,: dx(sĉ 򓊭RS@,Ҽb<+ҤҼRݜĒoŊSKJ tJ3sR*tK2ʌ'Ma/P[SZZQ_Z46[*6wZ%'&gZ)Tڦg$mtI>BR'7?%67bZɦ~^Dc)Ax]RMkA&PXIҠֵnj>Bݷm73YIC[urg _x&ƥ<~<ǟ||~ק ۹J{IQeV>L寥wD"xr(.(8DhwQ,^)iGՅ"Ț}l'wL+Mn@[D5k8 |ƓLudUhQ= Z<}O',^kjH_e=Kf\gbVO|X@~qx9S0::#q(CΨ@g ʄ>k`șn3z 4ax&>?rƏKB|Ǝ Tӹa߳^u5B.L}hlk'MbR4Ǫ