Verdet

Light goes one way. Privacy layer for tokenized equities. The chain shows a transfer happened, not who holds the stock.

[Verdet @Verdetapp]

$VDRT is live on Robinhood Chain, launched through pons.

CA : 0x63c54a6f4260d8075a33ec28245edfc3bbf898df

Tokenized stocks brought the market on chain and brought the tape with it. Your position, your entry, your exit, your average, all readable by anyone with a block explorer, and read by funds before they quote you.

You are the only participant who never agreed to that.

Verdet is the one-way path. The trade goes through. The trail does not come back.

Trade : https://t.co/xMpq3sGV0C

[Verdet @Verdetapp]

One address to publish. A different one for every payment that arrives at it.

Left: the recipient, once. Two key pairs and a meta-address, which is the only string they ever publish. The spending key moves funds. The viewing key only finds them, which is why it can be handed to a scanner.

Right: the sender, every time. They take that published string, generate an ephemeral key, and arrive at an address nobody else can compute. Send a hundred payments to the same meta-address and you get a hundred addresses with nothing on chain joining one to the next.

The asymmetry is the whole design. The recipient publishes once and the sender derives fresh, so the thing that is public is not the thing that receives.

Both of these are one command each, from a package with no network in it. Run them a hundred times and watch the right-hand column never repeat.

[Verdet @Verdetapp]

The derivation now runs in a terminal.

npx @verdet/stealth

No install, no wallet, no account, no site. It derives a spending key and a viewing key, builds the meta-address you publish, and turns anybody else's meta-address into the one-time address a payment to them should go to. That is ERC-5564, and it is the whole of what this product does to keep two payments from being joined.

There is no network anywhere in the command or underneath it. Nothing reads a chain, posts an announcement or contacts a registry, which is what makes it safe to run on a machine you care about and what makes its output something you can check against any other implementation of the spec.

Private keys are not printed unless you ask for them, because a secret on a terminal is a secret in a scrollback buffer and probably in a shell history. That takes a flag, and it prints what it costs you.

The package is @verdet/stealth. The source is the thing you are trusting, so read it first.

[Verdet @Verdetapp]

A privacy tool that routes your reads through its own server has moved the problem, not solved it, unless it can say exactly what that server holds. So here it is.

Three hops carry a read. The first one is the only place your address and your IP exist together, and it lasts as long as the request. The second drops your IP and every browser header before the proxy sees anything. The third reaches a public endpoint that sees the address paired with our server and never with you.

Six fields is the whole vocabulary of our logger, and none of them is an argument, which is where every address lives. That is not a policy. The type accepts six fields and there is no overload taking a request or a body, so a line carrying an address cannot be written without somebody widening the list first. A test reads the proxy's own source and holds this table to it.

The weak link is named too: we do not operate the platform that collects those lines, so its retention is its policy and not our promise.

https://t.co/6N7qKDI60h

[Verdet @Verdetapp]

Ten things, one wallet. All of it is in the app now.

Nothing here is a separate page you have to go and find any more. The wallet, five ways of moving value without announcing it, the scanner, a watch-only view, an audit that reads any address, and staking. Same rail, same keys, one tab.

The last two are new and sit under their own headings for a reason. Reading a chain is not a wallet operation, and staking is a public act tied to an address, which is the opposite of everything above it in that list. They are grouped so that nobody drifts from one into the other by accident.

Amounts, timing and the sender stay readable to anyone in all ten. What Verdet works on is linkage.

https://t.co/WyAaMUhF8B

[Verdet @Verdetapp]

The intro film is finished. 2:22, and you can rebuild it yourself.

19 shots across 7 scenes, 4,260 frames, no face and no stock footage. It is a browser being driven through the real site, with the narration, the bed and the graphics laid under it by three commands anybody with the repository can run.

That matters more here than it would on most products. The argument of this thing is that you do not have to take our word for it, and a demonstration only one person can produce is our word. If the site changes, the film changes with it, and if we ever film something the site does not do, the next person to run those commands will see it.

Building it found three bugs in itself. A highlight that was two green lines because the element was wider than the frame. A shot whose scroll fraction had gone stale and filmed the wrong panel under the right narration. And then the same shot highlighting the wrong feature, because a card's text contains the words about its neighbours.

https://t.co/aAi1lnX1C7

[Verdet @Verdetapp]

Put in any address. See what it holds.

The observer answered what an address had touched, built from transfer logs. That is a different question and a misleading one: a position moved out years ago still leads a transfer count.

It now reads a balance for every equity we have a record of, live, at the moment you press the button. The scale is read from the chain rather than taken from our note of it, because these are beacon proxies and a drifted record does not look wrong, it looks like a balance.

No prices. There is no oracle here we would stand behind.

https://t.co/aG3gO0pLv1

[Verdet @Verdetapp]

See everything. Move nothing.

One string carries a viewing key and a spending public key. Together they rebuild every address the wallet ever handed out, and they sign nothing, because the spending private key is not in there and cannot be derived from what is.

That is what an accountant needs, what an auditor needs, and what a second device of your own needs. It is also what a bookkeeper should be given instead of a wallet, which is what usually happens.

The grant is a string with a four byte checksum, so a key typed wrong is rejected rather than silently producing an empty wallet that looks like a wallet with no money in it. Version 2 carries a scope label, so a holder can read from the bytes whether they were given a period or the lot.

The reader uses the identical code path the wallet uses: one derivation for a wallet, the same one for a watcher, so the two can never disagree about what you hold.

[Verdet @Verdetapp]

Show somebody a code. Get paid. Nothing survives the payment.

This is the feature the rest of this product is built to make possible, and it is the one that is hardest to explain, so here is the whole of it.

Every stealth scheme has a hole, and it is not on the chain. A meta-address is joined to nothing by the ledger, and it is a persistent identifier off it. Publish one and give it to ten payers, and those ten can compare notes and learn they are paying one person. The chain protected you and the paper did not.

A private request closes that. Your wallet derives the address, so the payer receives one address and nothing that outlives the payment. Hand request 0 to one payer and request 1 to the next, and the two share nothing at all.

Because you chose the ephemeral key, nothing has to be announced. What lands on chain is one ordinary transfer to one ordinary-looking address, with no marker anywhere that a privacy tool was involved. No announcement to scan, no contract of ours in the path, no relay, and nothing for anybody to pattern-match on later.

Then you scan. The wallet walks its own request numbers and finds the money, because every address regenerates from your two keys and an index. Lose the counter and you lose nothing; a wallet restored on another machine walks the numbers again and finds all of them.

[Verdet @Verdetapp]

Wallet audit and staking are live in the app.

Both were pages beside the product. They are now tabs inside it, in the same rail as the wallet, under headings that say what they are: one reads a chain, one is about a token, and neither is a wallet operation.

Wallet audit. Put in any address and read what it holds across every equity we carry a record of, live, at the moment you press it. The scale is read from the chain rather than from our note of it, because these are beacon proxies and a drifted record does not look wrong, it looks like a balance. No prices, because there is no oracle here we would stand behind.

Staking. 5.00 per cent a year, simple, with the arithmetic on the page. That is the low end of an ordinary programme on purpose: a headline rate is the cheapest thing to print and the most expensive to keep. There is no staking contract yet, so nothing takes tokens today, and the screen says so rather than implying otherwise. Anyone asking you to send $VRDT somewhere to stake it right now is taking it.

Staking sits under its own heading, with a gap above it, for a reason. It is a public act tied to an address, and everything above it in that rail exists to stop exactly that. Stake from a wallet you have never received a stealth payment into.

https://t.co/WyAaMUhF8B

[Verdet @Verdetapp]

The derivation layer is published.

npm i @verdet/stealth

Stealth addresses, linkable ring signatures, sigma-protocol proofs and oblivious transfer over secp256k1. Two dependencies, both audited, neither of them ours. 151 tests. The source ships in the tarball, so the code you audit is the code you installed, and npm reports a verified registry signature on every package in the tree.

An implementation nobody can read is a claim, and a claim is not what you want standing between you and your keys.

https://t.co/084FwCCdzK

[Verdet @Verdetapp]

One address to publish. A different address for every payment that arrives at it.

Nothing on chain joins one to the next. The derivation runs in your browser, on contracts we did not write and cannot switch off, and every address regenerates from your keys and an index, so a wallet restored on another machine finds all of them again.

https://t.co/aAi1lnX1C7

[Verdet @Verdetapp]

Verdet Product Knowledge

[Verdet @Verdetapp]

Nothing here needs to be taken on trust.

The contracts this wallet receives through were deployed by other people. Every address can be confirmed in one request against any public endpoint for chain 4663.

One curl. No account.

[Verdet @Verdetapp]

Accumulate without announcing.

The same 1,000,000 units. The same 6 fills, same sizes, same times, one baseline, one scale. The only thing that changes is where each fill lands.

Left: every fill to one address. The position builds into a single figure, and by the third tranche the shape of the order is legible enough to be priced against before it is finished.

Right: every fill to an address derived fresh. The same 6 fills of 166,667. Nothing on chain joins them, so there is no position to read and nothing to trade ahead of.

Verdet works on linkage. Amounts and timing stay readable to anyone in both columns, and spending from several of those addresses joins them again, permanently. That is the honest shape of it.

Your own size and tranche count are on the page.

https://t.co/RIVdwKAO9m

[Verdet @Verdetapp]

Left: one address, every payment landing on it, readable forever by anyone.

Right: the same payments, each at its own address, with nothing on chain joining one to the next.

Same money. Same chain. A different public record.

[Verdet @Verdetapp]

and protect all your assets with the all-in-one privacy feature $VRDT

[Robinhood @RobinhoodApp]

stocks by day, crypto by night, all in one app

[Verdet @Verdetapp]

One meta-address, published once.

Every payment to it lands somewhere new, with nothing on chain joining one landing to the next. They share a source and the geometry joins none of them.

On contracts that were already there before we were.

[Verdet @Verdetapp]

Who can tell that two payments went to the same person?

With a published address: anyone holding it, forever. With a private request: nobody, because the payer never receives anything that outlives the payment.

One address, handed over once, reusable by no one.

[Verdet @Verdetapp]

Being paid privately, in three moves.

Hand one payer one address. They send an ordinary transfer to an ordinary-looking address. Your wallet rebuilds it from your keys and finds the money.

No announcement.