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