Alchem-Link v0.23.0
An Alchemy × Chainlink developer toolkit that reads chains instead of documentation. Live oracle reads, a consumer-safety audit, measured feed behaviour, and a simulator that replays your guards against the failure modes that have already cost people money — from the command line, a full-screen dashboard, or Python, with no dependencies at all.
Not "no dependencies except the UI". The terminal system is in the package: screen
diffing, colour-depth negotiation, input parsing, widgets and the event loop all live in
alchem_link.term. pip install alchem-link pulls nothing, and that now includes the
dashboard.
pip install alchem-link
alchem-link price ETH/USD
ETH / USD (ethereum)
price 1,929.60
status FRESH
updated 18m 7s ago (heartbeat 1h)
round 129127208515966893596 (phase 7)
aggregator 0x5f4eC3Df9cbd43714FE2740f5E3616155c5b8419
No API key needed to start. Set ALCHEMY_API_KEY when you want real rate limits.
The problem this exists for
latestRoundData() succeeding tells you almost nothing. It succeeds when the feed has
not published in a day, when the answer is pinned against a circuit breaker, when the
round is a carried-over duplicate, and — on an L2 — when the sequencer has been down for
an hour and the price is a fossil. Every one of those returns a well-formed number and
raises nothing. Each has cost real protocols real money.
alchem-link audit runs the checks a careful consumer contract would:
alchem-link audit ETH/USD -n base
ETH / USD (base) 1,930.24 [ok]
0x71041dddad3595F9CEd3DcCFBe3D1F4b0a16Bb70
[info] BOUNDS_WIDE: circuit breakers are far from the current price
the price would have to fall 1.93e+11x to reach minAnswer
[info] SEQUENCER_OK: L2 sequencer is up and past its grace period
up for 3619518s, past the 3600s grace period
| Check | Catches |
|---|---|
STALE |
Fresh-looking answer that has not published within its heartbeat |
NON_POSITIVE |
Zero or negative answers, which are never real quotes |
INCOMPLETE_ROUND |
updatedAt == 0 — a round started but never finalised |
CARRIED_ROUND |
answeredInRound < roundId — no fresh answer this round |
BOUNDED_ANSWER |
minAnswer/maxAnswer near the price — the LUNA failure mode |
SEQUENCER_DOWN / SEQUENCER_GRACE |
An L2 whose sequencer is down, or back up but not long enough |
DESCRIPTION_MISMATCH |
An address filed under the wrong pair |
DECIMALS_MISMATCH / NON_STANDARD_DECIMALS |
Consumers hardcoding 1e8 |
BOUNDED_ANSWER is the one worth explaining. An aggregator with circuit breakers
cannot report outside them. When LUNA fell through its floor, the feed kept returning
the floor — fresh, well-formed, and orders of magnitude wrong. Seeing it requires
resolving the proxy and reading the bounds off the implementation, which is what
alchem-link inspect does.
Heartbeats are measured, not copied
This registry used to declare 3600 for every feed, inherited from Ethereum mainnet.
That is wrong almost everywhere, and wrong in the dangerous direction:
| Network | Real ETH/USD heartbeat | A 3600s check would… |
|---|---|---|
| Polygon | 60s | miss a dead feed for an hour |
| Optimism / Base | 1200s | miss it for 40 minutes |
| Arbitrum (USDC) | 300s | miss it for 55 minutes |
| Ethereum | 3600s | be correct |
Every heartbeat in the registry now comes from walking that feed's own round history. The trick is that Chainlink publishes on either a heartbeat or a deviation threshold, and the two leave different fingerprints — intervals pile up against a ceiling (the heartbeat), and anything arriving well inside it was triggered by price movement.
alchem-link cadence ETH/USD -n optimism
ETH/USD (optimism) [matches]
declared 20m
observed 20m (ceiling 1212s, median 442s over 39 intervals)
triggers 8 by heartbeat, 31 by deviation
deviation threshold is at most 0.1509% (largest move seen 0.407%)
It also knows when it cannot tell you. On a fast L2 the price may never sit still long enough for the clock to trigger a publish, and the window's longest gap is then a lower bound, not a measurement:
ETH/USD (arbitrum) [not observed]
every round in this 2941s window was deviation-triggered, so the heartbeat was never
exercised — it is at least 451s, and the declared 3600s is not contradicted.
Feeds whose heartbeat is a bound rather than a measurement are marked * in
alchem-link feeds.
Cross-chain divergence
ETH/USD is not one number. It is a separate oracle deployment per chain, and they do not agree:
alchem-link divergence ETH/USD
ETH/USD [agree] consensus 1,923.88
ethereum 1,929.60 +29.7 bps 48m 19s old
linea 1,926.54 +13.8 bps 1h 49m old
scroll 1,925.97 +10.9 bps 1h 22m old
bnb 1,921.96 -10.0 bps 43s old
polygon 1,923.07 -4.2 bps 8s old
...
10 chains agree — worst leg 29.7 bps from consensus (threshold 50)
Stale legs are excluded from consensus — a feed past its heartbeat is not evidence about the current price — and outliers are attributed, so a lagging chain is not confused with a broken one. Testnets are excluded entirely: Sepolia's feeds carry unrelated data, and averaging them in produces a consensus that describes nothing.
Generate a consumer that passes the audit
alchem-link generate ETH/USD -n base
Emits dependency-free Solidity with the address, the measured heartbeat, and — because the target is a rollup — the sequencer gate and grace period:
uint256 public constant MAX_AGE = 1380; // measured 1200s heartbeat + 15% slack
if (sequencerStatus != 0) revert SequencerDown();
if (sequencerStartedAt == 0) revert SequencerDown();
if (block.timestamp - sequencerStartedAt <= GRACE_PERIOD) revert GracePeriodNotOver(...);
if (updatedAt == 0) revert IncompleteRound();
if (block.timestamp - updatedAt > MAX_AGE) revert StalePrice(updatedAt, MAX_AGE);
if (answer <= 0) revert InvalidPrice(answer);
if (answeredInRound < roundId) revert StaleRoundAnswer(answeredInRound, roundId);
Generate the same feed on Ethereum and the sequencer lines are absent — they would be
noise on an L1. --lang typescript and --lang python emit equivalents.
Would your guards have caught it?
audit tells you about a feed as it is right now. simulate asks the question that
actually decides whether a protocol survives: given the checks your contract performs,
what would have happened?
alchem-link simulate
scenario result accepted what it takes to catch
healthy clean 8/8 a good guard accepts every round here
bounded_crash MISSED 10/10 needs a consumer-side price bound or a move limit — staleness will not catch it
frozen_feed caught 5/10 caught by a staleness window sized to the real heartbeat
sequencer_outage MISSED 10/10 needs the sequencer uptime gate; the price feed answers throughout
carried_rounds MISSED 10/10 needs answeredInRound >= roundId
flash_spike MISSED 7/7 needs a move limit; the spike is fresh, positive and complete
incomplete_round caught 5/6 needs the updatedAt != 0 check
clock_skew caught 5/6 needs signed age arithmetic; unsigned subtraction underflows here
4/8 scenarios handled (50%)
gaps: bounded_crash, sequencer_outage, carried_rounds, flash_spike
try --strict, or turn on the specific guard each gap names
That is the default guard — a staleness window and a positivity check, which is what
most integrations have. --strict turns everything on and handles all eight. --naive
is latestRoundData() and nothing else, and handles two.
bounded_crash is the one worth staring at. It is the LUNA shape: the price falls
through the aggregator's minAnswer and the feed pins to the floor. Every observation
after that is fresh, positive, complete, and orders of magnitude wrong. Staleness
cannot see it. Only a consumer-side bound or a move limit can.
There is a healthy control in the set on purpose — without it, a guard that rejects everything would score perfectly.
Then check the other direction, against real history:
alchem-link backtest ETH/USD -n base --strict
Rejections there are false positives: rounds the feed legitimately produced that your guard would have thrown away. A guard that scores 8/8 on the scenarios and rejects a third of real history is not a guard anyone can ship.
Statistics that account for how oracles publish
alchem-link stats ETH/USD -n base
ETH/USD (base) 30 rounds over 8h 20m
last 1,930.24
change +0.412%
range 1,918.00 – 1,944.51 (1.38%)
twap 1,926.88
vs twap +17 bps
volatility 31.4% annualised
max drawdown 0.884%
largest move 94.2 bps
interval median 20m
Two of those numbers are computed differently from how a naive implementation would.
TWAP is time-weighted, not sample-weighted. An oracle publishes on a heartbeat or on a deviation threshold, so it prints most often precisely when the price is moving — which means the mean of the answers systematically over-weights volatile periods. A price that sat at 1,900 for fifty minutes and then walked to 1,950 over six one-minute rounds has a sample mean of 1,921 and a time-weighted mean of 1,902: the flat stretch was 90% of the window but only two of the seven prints. The second number is what a TWAP oracle would have reported, and spot is 253 bps above it.
Volatility is scaled by measured spacing. Annualising needs the sampling interval; assuming one is how the same asset reports wildly different volatility on Polygon (60s publishes) and Ethereum (3600s). The interval comes from the timestamps.
Commands
Live — price · feeds · audit · inspect · history · updates · stats ·
cadence · divergence · sequencer · watch · gas · holdings · transfers ·
block · doctor · verify · ccip
Offline — search · networks · coverage · simulate · backtest · theme
Interactive — ui · shell · chat · providers
shell and chat take --workspace DIR, --yes, --allow-exec and --read-only.
Reference and codegen — generate · alchemy · chainlink · integration ·
blueprint · recipes
Every command takes -n/--network, --rpc-url, --no-color and --format.
--format — one flag, every command
Every result object exposes as_dict(), so anything that returns a list can be emitted
as json, ndjson, csv, markdown or a Prometheus scrape body:
alchem-link feeds --live -n polygon --format prometheus
# HELP alchem_link_feed_stale 1 when the answer is older than its heartbeat plus tolerance
# TYPE alchem_link_feed_stale gauge
alchem_link_feed_stale{network="polygon",pair="ETH/USD"} 0
alchem_link_feed_age_seconds{network="polygon",pair="ETH/USD"} 41
Scrape that on a timer and alchem_link_feed_stale == 1 is a complete alert rule — the
tool stops being something you run when you are worried and starts telling you when to
be.
Batched reads
Reading a network's feeds means three eth_calls each. Done naively that is 48 round
trips on Ethereum — about 20 seconds on a public endpoint. The toolkit collapses them
through Multicall3, falls back to JSON-RPC batching where Multicall3 is not
deployed, and reports which tier it used:
ethereum 16/16 OK 607ms http=2 logical=50
The tier matters beyond speed. Multicall3 executes every sub-call in one EVM invocation, so all 48 reads come from the same block — without which comparing two feeds means comparing two different moments.
Verified registry — 66 feeds, 11 networks
Every address ships only after being called for description() and decimals(), and is
filed under the pair the contract itself reports. That check keeps earning its place:
- The address widely shared as Base "BTC/USD" reports
WBTC / USD— a wrapper that can depeg. Registered under its real name, with a note. - The Gnosis address commonly labelled "xDAI/USD" reports
DAI / USD. - Two candidate CCIP routers had no code at all and were dropped.
alchem-link verify -n base
| Network | Chain ID | Feeds | |
|---|---|---|---|
ethereum |
1 | 16 | CCIP |
sepolia |
11155111 | 3 | testnet, CCIP |
base |
8453 | 6 | L2, uptime feed, CCIP |
arbitrum |
42161 | 8 | L2, uptime feed, CCIP |
optimism |
10 | 6 | L2, uptime feed, CCIP |
polygon |
137 | 7 | CCIP |
avalanche |
43114 | 5 | CCIP |
bnb |
56 | 5 | CCIP |
gnosis |
100 | 4 | |
scroll |
534352 | 3 | L2 |
linea |
59144 | 3 | L2 |
Endpoint resolution, most explicit first: --rpc-url, then ALCHEMY_URL, then
ALCHEMY_API_KEY combined with the network's Alchemy subdomain, then a keyless public
endpoint. doctor always reports which one is in use, with any key redacted.
Gas, priced in dollars
eth_gasPrice returns one number and hides the structure. eth_feeHistory returns the
base fee, the priority-fee percentiles, and — because EIP-1559 fixes it from the parent
block — the next block's base fee as fact, not forecast. And since the package already
reads Chainlink, the estimate converts through the native token's feed on the same chain:
alchem-link gas
ethereum (20 blocks sampled)
base fee 0.2057 gwei → next block 0.2215 gwei [rising]
congestion 48% of target
ETH/USD 1,929.60
tier tip (gwei) max (gwei) transfer swap
slow 0.0009 0.4438 $0.0090 $0.0772
standard 0.1500 0.5930 $0.0151 $0.1290
fast 1.8970 2.3400 $0.0858 $0.7358
That composition is the whole Alchemy-plus-Chainlink premise in one command: chain state from the node, valuation from the oracle.
CCIP
CCIP does not address chains by chain ID. It uses 64-bit chain selectors — Ethereum
is chain ID 1 and selector 5009297550715157269 — and passing one where the other belongs
compiles, deploys, and reverts. Every router here answers typeAndVersion() as
Router 1.2.0, and every lane is confirmed against the router's own isChainSupported:
alchem-link ccip -n base
router 0x881e3A65B4d4a04dD529061dd0071cf975F58bCD (base)
arbitrum selector 4949039107694359620 open
ethereum selector 5009297550715157269 open
sepolia selector 16015286601757825753 closed
Python API
One object holds a network, a connection and a per-feed cache, so a session is one client rather than one per call:
from alchem_link import connect
link = connect("base")
link.price("ETH/USD") # one round trip
link.price("ETH/USD") # cached — no round trip
link.audit() # reuses the same client and Multicall3 probe
link.stats("ETH/USD") # TWAP, volatility, drawdown over recent history
link.everywhere("ETH/USD") # every chain that carries it, concurrently
link.rpc_stats() # what the whole session actually cost
Cache TTLs come from each feed's measured heartbeat, not a constant — a Polygon feed
on a 60-second cadence caches for 20 seconds, an hourly mainnet feed for two minutes.
price(..., strict=True) raises StaleFeed instead of returning a reading that says so,
for the contract-facing paths where forgetting to check .stale is the bug.
Every exception descends from AlchemLinkError, and the ones that replaced a builtin
still inherit it — UnknownNetwork is a KeyError, AbiError is a ValueError — so
nothing that caught them before stops working.
The functional API is unchanged:
from alchem_link import read_feed, audit_feed, profile_feed, compare_pair
reading = read_feed("ETH/USD", network="polygon")
if reading.stale:
raise RuntimeError(f"{reading.pair} is {reading.age_secs}s old — refusing to trade")
audit = audit_feed("ETH/USD", network="base")
if not audit.safe_to_consume:
for finding in audit.sorted_findings:
print(finding.severity, finding.code, finding.detail)
profile = profile_feed("ETH/USD", network="arbitrum", rounds=120)
print(profile.observed_heartbeat, profile.heartbeat_verdict)
report = compare_pair("ETH/USD")
print(report.spread_bps, [leg.network for leg in report.outliers])
Batched reads of arbitrary contracts, with the ABI codec exposed:
from alchem_link import Call, batch_call, client_for, encode_call, selector
print(selector("latestRoundData()")) # 0xfeaf968c — computed, not stored
rpc = client_for("ethereum")
report = batch_call(rpc, [
Call(token, "balanceOf(address)", (wallet,), ["uint256"], "balance"),
Call(token, "symbol()", (), ["string"], "symbol"),
])
print(report.tier, report.block_atomic, report.by_label("balance").one())
History from event logs rather than by walking rounds — one eth_getLogs instead of a
hundred eth_calls — plus the statistics over it:
from alchem_link import Series, answer_updates, summarise
updates = answer_updates(address, hours=24, network="base")
stats = summarise(Series.from_updates(updates, "ETH/USD", "base"))
print(stats.twap, stats.volatility_annual, stats.max_drawdown_pct)
Fan a read across every chain that carries a pair, concurrently, with failures reported as rows rather than raised:
from alchem_link import read_pair_everywhere
sweep = read_pair_everywhere("ETH/USD")
print(sweep.values(), sweep.failed, f"{sweep.speedup:.1f}x")
Replay your consumer's guards, offline:
from alchem_link import Guard, audit_guard
result = audit_guard(Guard(max_age_secs=3600, require_positive=True))
print(result.score, result.failed) # 0.5 ['bounded_crash', 'sequencer_outage', ...]
Zero dependencies, including the hash
hashlib ships SHA3-256, which is not Keccak-256 — NIST changed the
domain-separation byte between the Keccak submission and the final standard, and
Ethereum froze on the original. That single byte is why so much Ethereum tooling reaches
for a native extension.
This package implements Keccak-256 in about a hundred lines of integer arithmetic, so function selectors are computed rather than trusted:
>>> selector("getRoundData(uint80)")
'0x9a6fc8f5'
That is what makes the ABI codec possible — including the (address,bool,bytes)[]
tuple-array encoding that Multicall3.aggregate3 requires — and it is pinned in tests
against the standard vectors and the four selectors this package previously shipped as
hand-verified constants.
As of 0.23.0 there is no optional extra either. The dashboard used to need textual,
which made the user interface the one place the zero-dependency claim was quietly
abandoned. It is not any more — see below.
One practical note baked into the client: several public RPC providers reject Python's
default Python-urllib/3.x User-Agent with a 403, which reads as "the chain is down" if
you have not hit it before. The client always sends a real one.
The agent can write code, not just talk about it
alchem-link shell
alchem:base › write me a consumer for ETH/USD on base, with tests
· audit_feed(pair='ETH/USD', network='base')
WRITE generate_project oracle/
scaffold a foundry project for ETH/USD into oracle/ (consumer, mocks, tests, deploy)
[y] once [a] always here [n] no [d] never here [v] view
approve? y
✎ generate_project(pair='ETH/USD', out='oracle')
Scaffolded a Foundry project in oracle/. The consumer checks staleness against
base's measured 1200s heartbeat, rejects carried rounds, and gates on the L2
sequencer with its grace period. Tests cover each failure mode.
changed: oracle/src/EthUsdConsumer.sol, oracle/test/EthUsdConsumer.t.sol, …
Twenty-eight tools: read, write and edit files, make and search directories, scaffold
projects, export results, and run commands. :tools lists them grouped by what they do
to your machine.
Codegen goes through the generator, not the model
When you ask for a Chainlink consumer the agent calls generate_consumer rather than
writing Solidity from memory, and the system prompt says so in as many words. The reason
is the same one the rest of this toolkit exists for: a model writing that contract from
training data produces something that compiles, looks correct, hardcodes 3600, and
omits the sequencer check. The generator bakes in that feed's measured heartbeat for
that chain and every check audit looks for.
A plausible-looking contract is the same class of failure as a plausible-looking price.
Three gates, not a checkbox
Everything the agent does to your filesystem passes through:
A workspace root. Paths are fully resolved — symlinks followed, .. collapsed — and
then compared against the root. Rejecting strings that contain .. is theatre; a
symlink inside the workspace pointing at / is not caught by it, and neither is a
Windows junction.
A secrets refusal that approval cannot override. This is the non-obvious one. Tool
results are sent to a third-party model, so reading .env is not a read, it is a
disclosure of your ALCHEMY_API_KEY to whoever runs the inference endpoint. .env, PEM
files, SSH keys, .npmrc, cloud credentials and Solana keypairs are refused before
the approval prompt, for reads as much as writes, and they do not appear in directory
listings or search results either. You cannot meaningfully consent to a disclosure you
have not been shown.
A prompt you can actually answer. It leads with the verb and the path, not the tool
name, and v shows the diff. Approving a write you have not seen is a keystroke, not
consent — and the edits where that matters are the ones that look routine.
WRITE write_file src/Consumer.sol
overwrite src/Consumer.sol — 84 lines, 3,201 bytes
[y] once [a] always here [n] no [d] never here [v] view
a grants for that directory for the rest of the session, not for the whole workspace
and not for the next one. Grants are never written to disk: a permission that
survives the process turns one distracted keystroke into a standing authorisation.
Execution is off until you turn it on
run_command is refused outright until --allow-exec, and then still prompts per
command. It runs without a shell — the command is split into an argument vector, so
pipes, redirection and ; are not interpreted. That costs some convenience and removes a
class of injection: the argument list in the approval prompt is exactly what runs, with
no second layer of parsing in between.
Defaults, and why
| Situation | Reads | Writes | Commands |
|---|---|---|---|
alchem-link shell |
yes | prompt | refused |
alchem-link shell --yes |
yes | yes | refused |
alchem-link shell --allow-exec |
yes | prompt | prompt |
alchem-link shell --read-only |
yes | refused | refused |
alchem-link chat "…" piped or in CI |
yes | refused | refused |
The last row is the important one. When there is no terminal, a prompt cannot be
answered, and treating silence as consent is how an agent quietly rewrites a repository
in a CI job. --yes is the explicit opt-out, and it has to be typed.
A refusal also tells the model why, accurately. "Running commands is not enabled in this session" and "the user was asked and declined" are different facts, and reporting the second when no prompt was ever shown leaves you arguing with an assistant about a decision neither of you made.
Steering it from the shell
:workspace [dir] show or move the directory the agent may write in
:trust what it may do without asking
:trust write stop prompting for writes, this session
:trust exec enable commands, this session
:trust readonly refuse writes and commands
:trust revoke drop every grant given so far
:changes every file written this session
:diff <path> what is in a file now
The terminal system
pip install alchem-link
alchem-link ui
Alchem-Link v0.23.0 base · 66 feeds · truecolor
ALCHEM-LINK ┏━ Live Feeds ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ETH/USD 1,930.24 FRESH 3m 21s ago · hb 20m ┃
Live Feeds ┃WBTC/USD 67,940.11 FRESH 1m 04s ago · hb 20m ┃
Safety Audit ┃ Wrapped BTC, not spot BTC — can depeg. ┃
Analytics ┃USDC/USD 1.00 FRESH 41m 12s ago · hb 1d ┃
Cross-chain ┗━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┛
...
Live Feeds · base ↑↓/jk scroll · tab pane · n network · r refresh · q quit
Fifteen panels, including the guard simulator and registry coverage. Every panel that
talks to a chain does so on a worker thread, so an RPC round trip never freezes the app,
and results cache per panel until r. n/N cycle networks, tab moves focus between
the rail and the panel, 1-9 jump, q quits.
It is black and blue before the first frame
Drawing black rectangles gets you a black pane. The columns past the last painted cell,
the scrollback above the prompt, and anything a subprocess writes all stay whatever colour
the terminal was. So alchem_link.term.boot repaints the terminal's own defaults via
OSC 11/10/12 — background, foreground and cursor — and hands them back on exit. That runs
from alchem-link, from alchem-link shell, and from the compiled binary, which is why
plain alchem-link price ETH/USD output sits on the same surface the dashboard does.
Colour is negotiated per stream and degrades rather than breaking: truecolor → xterm-256
→ the basic sixteen → none. NO_COLOR, a pipe, or --no-color each reduce output to
plain text with the layout intact — the tests assert the two are character-identical,
because this output goes into CI logs and issue reports at least as often as onto a
screen. On Windows, VT processing is enabled through the Win32 API first; without that
call the whole UI renders as visible ←[38;2;…m garbage.
What is actually in there
| Module | Job |
|---|---|
term/ansi.py |
escape sequences, colour-depth negotiation, display-width measurement |
term/screen.py |
double-buffered cell grid emitting only the runs that changed |
term/input.py |
raw mode, and a pure parser from escape sequences to named keys |
term/widgets.py |
panels, tables, sparklines, gauges, tabs, scroll state |
term/app.py |
event loop, worker pool, resize handling |
term/boot.py |
terminal initialisation — and putting it back |
An idle frame costs zero bytes: the screen diffs the back buffer against what is actually on the terminal and emits one cursor move per changed run. That is the difference between a dashboard that is usable over SSH and one that is not.
The layering is strict — ansi knows about bytes, screen about cells, widgets about
rectangles, app about events — and nothing in the subpackage imports anything from
alchem_link except the inert palette, so it can be read and reused on its own.
Testable without a terminal
Panels render to a list of (text, style) lines; the app paints a window onto that list.
Scrolling and clipping are one slice on one list, and every renderer is a pure function —
so tests/test_dashboard.py exercises all fifteen panels in their loading, empty and
error states without a terminal in sight. That matters more here than usual: a dashboard
that crashes takes the whole screen with it.
Standalone binaries
No Python needed on the target machine, and nothing to collect — the package has no dependencies to bundle:
pip install pyinstaller
pyinstaller alchem-link.spec # the CLI
pyinstaller alchem-link-ui.spec # the dashboard
A binary launched by double-click lands in a fresh console with no TERM at all, which is
where colour detection has the fewest hints and where theming matters most. boot detects
the frozen case and themes it anyway.
The palette
alchem_link/theme.py is the single source: an inert table of hex values and semantic
Style roles, with no escape sequences in it. ansi encodes a role for whatever depth is
available; render uses the same roles for line output; the web build under
web/lib/alchem/ mirrors the same values.
tests/test_theme.py fails the build if any render module hardcodes a colour, if a role
paints on an undefined surface, or if the three status colours collapse into each other
once quantised to 256 or 16 colours — which is how a "harmless" palette tweak stops a
STALE badge from being distinguishable on a bare console.
alchem-link theme # the palette, and what this terminal negotiated
Web build
The same reader runs at /alchem-link in the Scematica dashboard (web/), porting
abi.py, networks.py and feeds.py to TypeScript under web/lib/alchem/ and serving
routes that read aggregators server-side, so ALCHEMY_API_KEY never reaches the
browser and CORS-less public RPC hosts still work.
This package stays authoritative. When the registry here changes, change
web/lib/alchem/feeds.ts too — /api/alchem/verify is what catches the two drifting,
because it asks the chain rather than either table.
Exit codes
| Code | Meaning |
|---|---|
| 0 | Success |
| 1 | Completed, but the result is not usable — a stale feed, a failed check, a divergence |
| 2 | Usage error — unknown pair, unknown network, missing argument, missing API key |
| 3 | Network error — endpoint unreachable |
| 4 | RPC error — the node answered with an error |
price exits non-zero on a stale read and audit on any finding at medium or worse, so
both drop straight into a CI gate.
Tests
python -m unittest discover -s tests
561 cases, all offline — no test in this suite reads a chain.
That is a design constraint rather than a convenience. analytics and simulate compute
numbers people size positions and write guards against, and a number that can only be
checked against a live chain cannot be checked at all. The RPC transport is stubbed at the
single-attempt boundary so the real retry policy stays under test; every dashboard panel is
rendered in its loading, error and empty states; and the terminal engine is exercised
against an in-memory screen, including the cases that are invisible until they are
catastrophic — a diff that reports "nothing changed" when something did, a wide character
that shifts every cell after it by one column, and an escape sequence emitted at a terminal
that would render it as literal digits.
Requirements
Python 3.10 or later. Nothing else.
The dashboard wants a terminal, but does not require much of one: it negotiates down to 256 colours, to the basic sixteen, and to no colour at all, and every command works unstyled through a pipe.
License
MIT
Metadata
Release files for alchem-link 0.23.23
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| alchem_link-0.23.23.tar.gz | 315.8 kB | Without provenance | Details for alchem_link-0.23.23.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| alchem_link-0.23.23-py3-none-any.whl | Python 3 | none | any | Details for alchem_link-0.23.23-py3-none-any.whl |
Total release size: 589.1 kB
Release files / alchem_link-0.23.23.tar.gz
| Download URL | alchem_link-0.23.23.tar.gz |
|---|---|
| Size | 315.8 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
41e92742ac5d800d993482cde2746eb3789e4fe9790979dfa01e1d90415e6a37
|
|
BLAKE2b-256 checksum How to use checksums |
686a74cea7595859fe9c2a3cf51c4962bc68a9f730e7867a00f522238d15aa3d
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/7.0.0 CPython/3.13.7
|
Release files / alchem_link-0.23.23-py3-none-any.whl
| Download URL | alchem_link-0.23.23-py3-none-any.whl |
|---|---|
| Size | 273.3 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
d1a91656eef494801f025110a6d39563a765cd34ba44d06b8da454d064ec0cac
|
|
BLAKE2b-256 checksum How to use checksums |
cd9e88a6bbfab28c835db567f229407098d50e2bc898d72f922e72982a581010
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/7.0.0 CPython/3.13.7
|
Security for alchem-link 0.23.23
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
No provenance found
None of the files in this release were uploaded with provenance metadata.
A note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.