Umbra is a privacy‑focused transaction and address layer built for the Solana ecosystem. It enables private transfers, swaps and regulated‑privacy flows - obscuring sender and recipient identities at the transaction level, while maintaining a secure and verifiable settlement path onchain. 

This design gives users control of sharing private transaction metadata (who pays whom, how much) while still settling to the public Solana ledger for auditability and verifiability. Umbra achieved this through a combination of fresh per-transfer keys, encrypted balance mechanisms, and a novel key architecture known as MVKs (Master Viewing Keys).

In a world where financial privacy and composability collide, Umbra presents a new model: privacy by default, compliance by design. Users benefit from stealth‑style transfers and isolation of transaction history; institutions and protocol teams benefit from built‑in controls and audit mechanisms. This makes Umbra especially relevant for regulated flows, real‑world assets, DAO treasuries, and protocols that require confidentiality without sacrificing governance and compliance.

To manage their compliance and risk - to prevent bad actors from shielding their transactions and laundering - Umbra is integrating Range's Onchain Risk Verifier, enabling real-time, verifiable risk scoring of counterparties directly within its smart contracts.

Why Umbra needs onchain compliance

Unlike private transaction layers that rely on off-chain relayers or UI-level permissioning, Umbra builds compliance directly into the protocol. Its compliance model is based on a few foundational components:

• MVK Address Architecture: Every Umbra user controls one or more Umbra addresses derived from a registered MVK. These addresses are used only once, isolating transaction history without breaking onchain settlement.

• Transaction Key Isolation: Each transaction is executed using a one-time-only transaction key. This key enables the linkage and decryption of the transfer by the recipient, without exposing sender or recipient identities onchain.

• Encrypted Balances and Claims: Transfers are stored in encrypted form and can only be claimed by the intended recipient, preserving confidentiality while allowing full onchain reconciliation.

• Onchain Registration and Access Control: MVKs are registered onchain in encrypted form, and cannot be accessed by Umbra directly. Only the MPC cluster as a whole can decrypt them, ensuring that private user data remains confidential - while still enabling auditability by authorized compliance entities when required.

This structure enables Umbra to operate as a regulated privacy system: preserving user confidentiality while still being able to enforce sanctions compliance, blocklist policies, or jurisdictional restrictions when needed.

But enforcement requires intelligence. That's where Range comes in.

Embedded onchain risk scoring with Range

By integrating Range's Onchain Risk Verifier, Umbra can now fetch and verify counterparty risk scores directly inside its program logic.

Here's how it works:

1. At the moment of transfer, the client or relayer requests a signed risk score from Range's API, using a Switchboard On-Demand Oracle.

2. The Oracle returns a signed quote with the verified risk score.

3. Umbra's program verifies the quote onchain, using Switchboard's Quote Verifier.

4. The verified score is used inside the contract to determine whether the transaction proceeds.

For example, Umbra can:

• Block transfers to addresses with high risk scores

• Prevent claims or withdrawals from wallets linked to malicious activity

• Enforce risk-based gating on MVK registration or per-user limits

Because Range's risk scores are signed and auditable, Umbra's logic remains transparent and verifiable - while still enabling private transaction flows.

How Range's Onchain Risk Verifier streamlines Umbra's compliance

Umbra's compliance architecture demands that enforcement happens at the contract level. Off-chain checks or UI warnings aren't enough. Risk checks must be verifiable, up-to-date, and enforceable - in real time.

By using Range's Onchain Risk Verifier, Umbra gains several distinct advantages in its design:

• Real‑time intelligence in program logic: Because risk scores come in via a signed feed, Umbra isn't relying on stale off‑chain risk tables or manual review. Each transaction sees the most up‑to‑date score.

• Cryptographic assurance: The use of signed oracle quotes ensures that Umbra's program is verifying a trusted data source and not relying on unverifiable heuristics.

• Embedded compliance gating: Instead of implementing policies only at the UI or backend level, Umbra now embeds the gating logic inside its onchain program. This improves control, reduces attack surface (e.g., malicious address bypass), and aligns with regulator expectations of embedded compliance.

• Threshold customizable logic: Umbra can define risk thresholds specific to various flows (MVK registrations vs. transfers vs. treasury payouts) and adjust them as its product evolves or as regulatory standards change.

• Auditability and trace‑back support: Because the risk check flows through a signed oracle job and onchain verification, Umbra retains a verifiable audit trail of which addresses passed or failed the check, which can be shared with authorized auditors under lawful process.

In short, Range's Onchain Risk Verifier brings the enforcement surface to where it belongs - the protocol layer.

Learn More

Umbra's selection of Range's Onchain Risk Verifier strengthens its position as a privacy‑first platform that also meets institutional and compliance needs. In this model, users retain confidentiality of their transactions - while Umbra retains the ability to enforce risk controls, monitor counterparty profiles and support regulatory audit demands.

Umbra's integration with Range is currently in testing and will go live with Umbra's mainnet launch. 

If you are building on Solana (or exploring EVM or CosmWasm) and want to embed real‑time, onchain risk intelligence inside your program logic, we'd love to talk. Learn more here, check the example repo, and book a demo at Range.