Contract monitoring
that reads the code.
Vigil takes a deployed contract, works out the claims that have to stay true for it to be working, and re-checks every one of them against the chain around the clock. Not a price alert and not a transaction feed: the fee still routes where it was pointed, the owner has not changed, the code has not been swapped underneath you, the keeper is still funded.
When one of those stops holding, it does not send a notification. It tells you which claim broke, which transaction broke it, and what that means.
Point it at anything on this chain.
This runs the read step live, in your browser, against the public node. Paste a contract address, or connect a wallet and use your own. Nothing is uploaded and nothing is stored until you ask for it to be watched.
What pays for it.
$VIGIL has a buyer that never stops. A contract fills up as the coin trades, and it can do exactly one thing with what it holds: buy $VIGIL on the open market and send it to a dead address. It does that every 30 minutes, 48 times a day, with no withdraw function and no owner. That pot is also the first thing the watch was pointed at.
The watch, on our own contracts.
What you already hold, and what can be done to it.
Watching a contract means knowing which one to name. Most holders never do: the token sitting in a wallet gives no sign that its code can be replaced, or that somebody can halt it, and this chain has no index that would say so. This reads the blocks for the addresses that have ever sent you anything, reads your balance in each, and puts the positions most can be done to at the top.
Connect a wallet and this reads what you are actually holding, then says what the contract behind each position is able to do: whether its code can be replaced, whether somebody can halt it, whether one address still owns it.
It is a read. Nothing is signed, nothing is sent, and the wallet is only ever used as an address to look up.
Contracts the engine keeps an eye on for you.
Connect a wallet and this section becomes yours: a list of contracts the engine probes every five minutes on your behalf, and marks the moment any of them changes underneath you.
The wallet is the identity your list is kept under. Adding to it asks for one signature, which proves you hold the wallet and nothing else. No transaction, no gas, no approval.
Read, derive, watch.
It pulls the deployed bytecode and, where there is verified source, the source with it. Storage slots, the proxy pointers, the functions that answer and the ones that do not. This is the same reading an auditor does on the way to a report.
Out of that come the claims. What the launchpad pays out still reaches the pot. The pot has adopted one token and has no function to adopt another. The upgrade slot is empty. The keeper is funded. Each one is a sentence the chain can be asked about.
Every claim is re-evaluated against the chain on a loop, the whole set in a single call so it stays cheap enough to run forever. A claim that stops holding comes back with what broke, what broke it, and what it means.
It holds no key on anybody's behalf and it sends nothing. A read-only watch has no blast radius, which is what makes it a thing a protocol can agree to in an afternoon rather than a quarter.
What is under watch.
Holds the ETH and does the buying. No withdraw, no owner, one token, forever.
Takes in what the launchpad pays out and forwards the burn budget to the pot. The pot it pays is immutable.
$VIGIL itself, launched by the pot so the pot is its recorded deployer.
Anything you put on your list gets the same five-minute read, kept, and diffed against the one before it.
Our own contracts first, because on day one the alternative is a screenshot of a protocol that never agreed to be watched. The pass is not written against these three: it derives what has to stay true from what it reads, which is exactly what lets it be pointed somewhere else.