Wendy 🇻🇳

Every compliance check needs data.
Sanctions screening needs to know who's sending. KYC verification needs to know the credential status. Source-of-funds checks need transaction history context.
But putting any of that on a public blockchain defeats the purpose of using a blockchain in the first place.
@NewtonProtocol built an encryption layer called the Newton Privacy Envelope - NPE - to hold identity and compliance data in a way that operators can evaluate without the blockchain ever seeing the underlying information.
Here's how it actually works.
When a user submits data for policy evaluation - an identity credential, a financial record, a compliance certificate - the client encrypts it locally using HPKE: Hybrid Public Key Encryption, defined in RFC 9180.
The encryption scheme combines X25519 for key encapsulation, HKDF-SHA256 for key derivation, and ChaCha20-Poly1305 for the actual data encryption.
What the client encrypts to is Newton's combined system public key - a threshold key produced through a Distributed Key Generation protocol among operators, stored onchain in the operator registry.
No single operator holds the private key. A quorum of operators must cooperate to decrypt - and even then, the decryption happens locally on each operator through threshold share exchange, never at a central point.
This matters for a non-obvious reason.
The NPE isn't just encrypted data. It's bound to a specific policy client, a specific chain, and a specific transaction intent through authenticated associated data.
That means a ciphertext encrypted for a stablecoin transfer on Arbitrum can't be replayed into a different context - a different application, a different chain, a different intent - even if an attacker captures the encrypted payload.
The binding is cryptographic, not just a rule in someone's code.
There's also a dual-signature authorization step before any decryption can happen.
The user signs the specific data references and intent with their Ed25519 key - proving they consented to this evaluation.
The application signs separately with its own Ed25519 key - proving the application is attesting to user consent.
Both signatures are required. A stolen application credential can't trigger policy evaluation without the user's signature, and vice versa.
Each encryption operation generates a fresh ephemeral keypair, giving every single message its own forward secrecy property.
If a long-term key is later compromised, past encrypted payloads stay protected.
During policy evaluation, each operator computes a partial decryption share using its portion of the distributed key and exchanges those shares through encrypted NATS channels - so even the messaging infrastructure sees only ciphertext.
Once a quorum of t operators contribute their shares, the plaintext reconstructs locally on each operator.
The blockchain records one thing: a boolean or minimal attestation proving a policy was evaluated and passed or failed.
Not the identity data. Not the credential content. Not the financial figures that went into the evaluation.
The chain sees the proof. It never sees the data behind it.
Newton is also building toward a Layer 2 privacy mode using Multi-Party Computation, where operators evaluate policies jointly over secret-shared data without any individual operator ever reconstructing the plaintext - eliminating even the operator-level visibility that exists in the current threshold decryption model.
The long-term privacy research tracks Fully Homomorphic Encryption, where policies could eventually be evaluated directly over encrypted data without decryption at any stage.
But even at the current Layer 1 architecture, the privacy guarantee for end users is already meaningful: compliance checks run, policies enforce, attestations record - and none of the personal data that drove those decisions ever touches a public chain.
$NEWT $BTC $ETH
#Newt

I expected buying a tokenized stock to feel complicated. It took less time than ordering coffee. Here's exactly what happened when I tried it.
Getting started was simpler than I expected. There are three ways to get a bStock: buy the underlying stock with token conversion toggled on and it auto-converts, convert a stock you already hold through the wallet's Token Conversion feature, or just buy the bStock directly under Spot > bStocks like any other asset. I went with the third option, since it felt the most straightforward for a first try.
The thing that actually surprised me was the settlement speed. No T+1 window, no "your order is processing" screen. It just filled and showed up in my wallet, the same way a regular spot trade does. And the market doesn't close at 4pm - I checked my position again later that night and it was still tradable.
What I didn't fully appreciate until I tried it: bStocks are BEP-20 tokens on BNB Smart Chain, so I could see mine sitting in my wallet like any other on-chain asset, not stuck inside a brokerage account I'd need to log into separately.
A few things worth flagging from the experience, not just the marketing version of it:
You're not buying actual shares of the company. It's structured as a Certificate representing a Financial Instrument, so you get price exposure and economic benefits like dividends, but no shareholder rights. The value still moves with the underlying stock, so normal market risk applies, and liquidity isn't guaranteed to be deep on every bStock at every moment.
There's also a tax detail I didn't know going in: dividends aren't paid in cash. They're auto-reinvested into your balance through a mechanism called the Multiplier, and a 30% US withholding tax applies before that reinvestment happens.
For a first trade, the whole thing took less time than opening a new brokerage account would have. Whether it replaces a traditional stock account depends on what you're optimizing for, but as a way to get fast, fractional, on-chain exposure to US stocks starting from just $5, it did exactly what it claimed to do.
If you want to try your first bStock trade the same way I did, this is the account I used - comes with a 20% lifetime fee rebate: https://www.binance.com/join?ref=WENDYYY
#BStocks

Here's a problem that sounds minor until you try to fix it.
A decentralized network of operators needs to evaluate a policy and produce a single BLS aggregate signature.
BLS aggregation only works if every operator signs the exact same message.
But what happens when the policy needs external data - a live sanctions list, a real-time oracle price, a risk score from a third-party feed - and different operators fetch slightly different values at slightly different times?
They can't sign the same message. Aggregation breaks. The whole model falls apart.
@NewtonProtocol solves this with a streaming two-phase consensus protocol built on NATS messaging.
Phase one is called Prepare.
The Gateway publishes a data-fetch request to all operators through NATS.
Every operator independently executes the same WASM data provider plugin - the sandboxed module that fetches external data - through its own network path.
No operator sees another's result during this stage. Each one produces its own ECDSA attestation over the data it observed.
Then they stream responses back to the Gateway as they finish, without waiting for a synchronization barrier.
The Gateway collects those responses and computes median-based consensus across numeric fields.
If operator A fetches a price of $1.0002 and operator B fetches $1.0004, the canonical value isn't either - it's the median across all responses.
This is the part worth pausing on.
The distributed WASM execution model means no single entity controls what data enters policy evaluation.
Not the Gateway, not any one operator, not a centralized oracle feed.
Each operator fetches independently, and the median removes outliers - whether from a slow network path, a stale cache, or a deliberately manipulated data source.
Phase two is called Evaluate.
The Gateway publishes the canonical consensus dataset to all operators.
Each operator fetches the Rego policy from IPFS by content address - the same CID, the same exact rule set - and evaluates it against the canonical data.
Because all operators now run the same deterministic policy against the same input, they produce identical results.
Identical results mean identical digests. Identical digests mean BLS aggregation actually works.
Operators sign, the Aggregator collects signatures, checks the stake-weighted quorum threshold, and exits as soon as enough signatures arrive - no waiting for stragglers.
This streaming approach matters for latency.
NATS messaging enables sub-second consensus because operators don't block each other. The Aggregator doesn't wait for every operator to respond, only for enough stake to cross the quorum threshold.
There's a simpler mode too.
When the data a policy needs is already deterministic or pre-cached, Newton skips the Prepare phase entirely and runs a single-phase evaluation - one NATS round-trip, lower latency, same cryptographic guarantees on the output.
The two-phase design gets pointed at one specific question: how do you preserve fully decentralized data fetching while still producing one consistent message that a BLS aggregate signature can cover?
Most systems answer this by trusting a single data source, a price oracle, a centralized feed.
Newton answers it by distributing the fetch, taking the median, and only then running policy.
The trust assumption shifts from "this oracle is honest" to "enough operators, across enough network paths, independently fetched data close enough to median."
That's a different security model - and a more defensible one at the scale onchain finance is moving toward.
$NEWT $BTC $ETH
#Newt

Everyone assumes new crypto regulation means more paperwork.
More disclosures, more reporting forms, more compliance officers reading PDFs after the fact.
That's not actually what the GENIUS Act, MiCA, FATF, or Hong Kong's Stablecoin Ordinance are asking for.
Traditional financial compliance runs at the interface layer.
KYC happens once, at onboarding. Transaction monitoring runs after the fact, as surveillance - alerts come in, someone reviews them, action gets taken days or weeks later.
That model assumed a custodian controlling execution.
In onchain finance, nobody controls execution. Users call smart contracts directly.
A sanctions-screened UI doesn't stop anyone from calling the contract straight - through a fresh wallet, a different RPC, a VPN to mask jurisdiction.
Regulators have noticed.
The frameworks below all share one demand, even if none of them phrase it the same way.
The GENIUS Act, signed into law in July 2025, requires reserve and redemption rules plus ongoing compliance controls for U.S. stablecoin issuers - not just onboarding checks.
Hong Kong's Stablecoin Ordinance, effective August 2025, demands the same from licensed issuers there.
FATF's Travel Rule guidance wants originator and beneficiary information transmitted with every qualifying transfer, not collected once and forgotten.
MiCA in the EU expects ongoing transaction monitoring from crypto-asset service providers, not a single onboarding screen.
Every one of these frameworks wants enforceable controls at the transaction level.
Audit evidence that a policy was actually applied - not logs claiming monitoring happened somewhere in the background.
That's the exact shape of problem @NewtonProtocol was built to solve.
Newton evaluates a policy against every transaction intent before it settles, and produces a cryptographic attestation - not a log entry, not an API response an application can quietly ignore.
The policy itself is written in Rego, the same language enterprises already use for cloud access control, and evaluated independently by a decentralized network of operators staked through EigenLayer.
That matters for the part regulation rarely talks about directly: cost.
Global financial crime compliance spending already exceeds $206 billion a year, with the average institution spending close to $73 million annually on AML and KYC work alone, much of it manual review.
Automating that screening at the transaction level, with cryptographic evidence attached, doesn't just satisfy a regulator. It removes a meaningful chunk of headcount-driven cost from the process.
The attestation gets recorded onchain.
A regulator can verify a policy was applied to a specific transaction without ever touching the underlying personal data, since the chain only sees proofs, never the identity behind them.
This doesn't mean Newton replaces a compliance department.
Issuers still define the policy. They still own the relationship with their KYC providers and sanctions data feeds.
What changes is where enforcement actually happens - at the smart contract, not in a dashboard nobody outside the company ever sees.
Regulation usually arrives years after the technology that needs it.
This time, the rules are already written before most of the infrastructure exists.
The open question is whether anyone actually builds the layer that satisfies them - instead of just claiming to.
$NEWT $BTC
#Newt