Introducing ArcLite. $LITE A private execution venue for tokenized equities on Robinhood Chain. Your order is encrypted in your browser, sealed into a batch, then crossed at a reference committed after the book closes. The settlement is proved onchain. > The market can verify the result without seeing every order before it happens. Your vault keys stay in your browser. Your balance is calculated locally. We are building privacy as infrastructure, we show the limits too: deposits are public, the matcher sees its sealed window, and early anonymity sets are small. Read the build: github.com/UseArclite/ArcLit… Try the dashboard: arclite.tech/dashboard

Withdrawing from ArcLite takes a few seconds because your browser is generating a ZK proof. It used to say "Proving…". Now: Finding your note → Building the witness → Generating the proof → Broadcasting. Each stage says where the work happens, the witness holds your note's secrets, so it's built in your browser and sent nowhere. We left out a "verifying locally" stage. The worker doesn't verify, so nothing claims it does. A progress bar that invents a step is a spinner that lies.

Gm, $LITE commmunity. Big build ahead main dev is taking over going to continue the build. The future of privacy starts with @UseArclite

Proof boundary: The price table only commits the rows it actually uses. The current circuit forces every unused selector to zero. No trailing padding row can feed a price the contract never committed. That is table membership. Not a live mid. Not best execution.

Founder/dev note: The issuer multiplier is not a UI label. After the book seals, it is committed beside the Chainlink reference in the price row the proof has to use. If a new multiplier is about to take effect, that asset waits. Input → committed row → proof.

We've open sourced the client half of ArcLite's shielded pool, so you can build one without writing it twice. Same logic has to exist in Noir and in the browser. Disagree by one field and the browser computes a commitment the circuit won't accept. MIT, 90 tests, fully offline. Notes regenerate from a key and a counter, so nothing you run is load-bearing for recovery. Disclosure scope is the key itself, not a flag. Spends are signed, not merely revealed. Our format, not a standard, take the design. github.com/UseArclite/shield…

Small registry detail: `STABLE` is not a vibe in the current source. It means USDG. A different token cannot call itself the quote asset just by using that label. That is a type check, not a market opinion.

Tech note: Pro-rata has to end in whole units. ArcLite floors every share, ranks the leftover fractions, then gives the last units to the biggest remainders. If the fractions tie, sealed-book sequence breaks it. No one gets to pick the leftovers.

Noir circuit, Solidity contract, same hash, get it wrong and there's no error. Just a Merkle tree your circuit proves against and your contract computes differently. Open sourcing ours. MIT, zero dependencies, verified against nargo vectors rather than against itself. Building ZK on EVM? Take it, and steal the three-element test: three elements exactly fill the rate, so Noir skips the final permutation. Permute unconditionally and you pass everything else while computing wrong roots. Trading on ArcLite? This is the hash your deposits are committed under. More eyes on it is the point. github.com/UseArclite/poseid…

Tree plumbing: A deposit can land while the commitment tree is still moving. Current source keeps 128 recent roots, not only the latest one. A proof built against a recent known root can still work after newer deposits. Recent, not forever.

Tech note: $LITE ArcLite pools are immutable. No proxy. No in-place patch. If a new pool is deployed, notes in the old one remain withdrawable there. An upgrade should not turn withdrawal into a migration task.

A suggestion that fails when you take it is worse than no suggestion. ArcLite tells you why a buy won't clear and what would fix it. Making that one click meant checking the number, and it was wrong by 86 quote units. Act on the advice, get refused again. First attempt stepped down one raw unit at a time. It ran and changed nothing: one unit of an 18-decimal asset is 10⁻¹⁸ of a share, eleven orders of magnitude too small. Closed form instead. Cost is an integer, the check is held × 100 ≥ cost × 102, so the exact maximum falls straight out. Every single-case test passed. The sweep caught it.

Small build note from the repo: A fix is not “done” because the source changed. We keep regression tests that fail on the old code, then verify the actual deployed contract. Source tells you what we meant to ship. The chain tells you what shipped.

Tech note: $LITE A proof is not a receipt printed after the trade. The contract checks it before the batch moves anything. If it does not verify, there is no settled trade and no spent note. That is why nullifiers only appear at settlement.

Before trusting a dashboard, find the contracts it is reading. ArcLite publishes the pool, asset registry, price committer and quote-token addresses. If the app says a rule is live, those are the addresses where you should be able to check it.

Tech note: Order intake gets a per-window hash, commitment, nonce hash and ciphertext. Not a wallet address. Not a cookie. After seal, the matcher can read that one book. It does not receive a handle that follows you into the next window.

ArcLite is now open source under MIT. The shielded note scheme, the Poseidon2 implementation, pure Solidity, byte-identical to Noir's stdlib and differentially fuzzed, the commitment tree, the circuits. All of it, yours to use. Private RWA execution on Robinhood Chain, and now anyone can build on the privacy layer underneath it. github.com/UseArclite/ArcLit…

We’re currently working on tier 2 listings. $LITE is at a state right now where we’d be eligible to apply to some. Meanwhile while we do applications, we’re still building the privacy infrastructure for builders to build on top of. More news to come. @robinhoodapp

Every exchange can hand you an account statement. ArcLite can't, and that's the feature. Orders here are salted per window so they can't be linked across windows. Which means there is no query on our side for "what has this person done". Not withheld. Not possible. So we rebuilt it where it belongs: in your browser, from your own keys. Deposits, orders, fills, withdrawals, one chronological list, merged from sources only a keyholder can reach. Exports to CSV in raw integer units and UTC, not rounded display amounts. It's the file you hand an accountant. A venue that can't produce your history is also a venue that can't hand it to anyone else.

"Did the last window settle?" is the first thing you ask after submitting an order. ArcLite couldn't answer it. The live clock showed the current window and the one before, then discarded everything. Now: the last 25 windows, with what became of each. The rows that matter are the ones marked voided or failed. They look like loss and aren't — nullifiers publish only at settlement, so a window that never settled left every note valid and every order resting. That's stated on the row, not left to a colour. A red label with no explanation is the scary half of a true story.