Two enforcement actions define how crypto regulation actually works, and neither is really about whether the technology is legal. The first is the designation of a smart contract rather than an entity. The second is the shift of enforcement onto the website that points at the contract, because a deployed program cannot be served a subpoena.
The practical consequence for anyone building is that compliance questions are usually about the interface and the operator, not about the code.
This guide walks that consequence through in order: where sanctions attach and how screening behaves once it is running, why enforcement concentrates on front ends, what stablecoin law now requires of issuers, and the design rules for compliance that respects privacy. It is written for the operator who has to make the calls — not for the lawyer who drafts them, and not as legal advice. The lane hub Web3 Economics carries the adjacent economic pieces; the specific regulatory claims here trace to the primary sources listed at the end.
Sanctions are address-level
The Office of Foreign Assets Control lists entities, and since 2022 it has listed smart contracts. Tornado Cash was designated in August 2022 — the first time a contract itself appeared on the list rather than the people who ran it — and Blender.io and Sinbad followed, both tied to the Lazarus Group. In the 2025–26 period the list has continued to grow.
For a protocol, the operational reality is this: interacting with a designated address can expose the front end and the people who operate it. So the compliance question is not "is our code lawful" but "which address do we refuse a transaction from, and who decides."
Screening runs through Chainalysis, TRM Labs, Elliptic, and CipherTrace, and integration takes one of four forms: an API check before a transaction, a webhook on flagged activity, batch screening of known user addresses, or continuous monitoring of active accounts. None of them is preventive — on-chain analysis traces funds after the fact — which is why the tooling answers "where did this come from" better than "should we allow this."
The four integration shapes trade coverage against latency. An API check before every transaction is the strictest and the easiest to explain to a regulator; batch screening of existing users catches the exposure that arrived before the integration; continuous monitoring is for accounts with standing balances; webhooks sit between. Small teams usually start with the pre-transaction check plus a weekly batch review of existing addresses, because both run from the same vendor call and neither needs real-time infrastructure. What matters more than the shape is the policy: what threshold triggers a review, who reviews, and what gets written down.
Screening in practice
In operation, screening is a review queue, not a wall. A hit lands in a list; a human classifies it against the written policy — false positive, explainable exposure, or refuse — and the classification gets recorded with a reason. The teams that get this right treat the queue as a weekly routine with an owner, the way a support inbox works. The teams that get it wrong either automate refusal on every raw hit, blocking legitimate users whose funds simply passed a popular bridge, or let hits age unread.
Keep a hit book: every refusal and every override, with the reason and the date. It is the difference between a compliance process and a compliance gesture, and it is the first thing anyone investigating an incident will ask for.
Where enforcement actually lands
The Fifth Circuit's 2024 decision in Van Loon v. Treasury curtailed Treasury's authority over immutable, non-custodial contracts, on the reasoning that a piece of immutable software is not a person whose property can be blocked. Treasury relisted the relevant addresses regardless, and the question has continued through the courts. This is unsettled law, and the practical reading for a builder is narrower than either headline: an immutable contract may sit outside sanctions reach while the website that points at it does not.
That is why the front end is the enforcement point. Interfaces, developers, and the DAOs that operate them are reachable; deployed contracts generally are not. Any team operating a UI over a permissionless protocol should assume the UI is where the regulatory exposure lives.
For a product surface, that reading breaks down by layer. A read-only dashboard that indexes on-chain data has the least exposure. A swap or bridge interface that constructs and submits transactions carries the most. Between them sit portfolio trackers with execution, front ends with optional relays, and wallets — each a different distance from the transaction itself. Teams rarely choose this exposure deliberately; it accrues as features ship. The right moment to have the exposure conversation is before the feature that submits transactions, not after the first letter arrives.
What stablecoin law now requires
Under US stablecoin legislation — the GENIUS Act and the framework around it — the compliance obligations are largely on the issuer rather than the protocol, and they are specific: 1:1 backing with high-quality liquid assets, regular independent verification of reserves, redemption within a defined window, minimum capital, and AML/CFT transaction monitoring.
That converts stablecoin compliance from a policy debate into an operational checklist. It also explains why the burden lands on issuers: they are identifiable entities with reserves and licences, which is exactly the property a protocol lacks.
For a creator or small protocol, the obligations read across rather than down: if you accept stablecoins for payments, the law constrains the issuer's side, but your operational exposure concentrates in custody and counterparty choice — which issuer, which custody arrangement, and what happens to receivables if an issuer has a bad day. Those choices are commercial, and the economics lane tracks the market side of them; the compliance-relevant step is simply knowing which stablecoins your business depends on.
The composability problem is the real one
Address attribution cannot resolve where funds came from once they have passed through a mixer, a bridge, or a chain of DeFi interactions. Every hop degrades the signal, and the output is a probability rather than a fact.
Any compliance programme designed around the assumption that attribution is definitive will block a large number of legitimate users while still missing the ones it was built for. The honest design uses screening as one input with a documented escalation path, not as an automatic refusal.
For a small team, the practical version of that honesty is boring: document what the screening covers, publish what users can do when they are blocked, and give the highest-risk category a named human. Most compliance failures in this space are documentation failures — the control existed, and nobody can show how it was applied.
KYC with privacy is now technically solved and socially unsolved. Privacy Pools and Railgun-style designs let a user prove their funds did not originate from a designated list without revealing which withdrawal is theirs. Attestations via Ethereum Attestation Service, ZK credentials from Polygon ID, and World ID let a user prove a predicate — over 18, resident in a jurisdiction, not sanctioned — without revealing identity. The blockers are liability (who owns a false attestation, the issuer or the verifier) and GDPR's conflict with immutable records, not cryptography.
What to do about it
Separate the three roles and keep them separate: an issuer who vouches, a holder who stores, a verifier who checks. Put personal data off-chain and only proofs on it, because a right to erasure cannot be satisfied by a ledger that does not forget. Bind proofs to a specific verifier and a nonce, or you have reintroduced replay attacks. And check revocation, because a credential issued in error or by a compromised issuer has to be cancellable without breaking every downstream proof.
A token-gating team has all three roles in miniature: the contract issuer vouches for the gate, holders store their credentials, and the front end verifies. The failure pattern is letting one component improvise all three — an interface that issues, holds, and verifies its own attestations has recreated the problem the separation exists to prevent. The token-gating guide covers the structural version; the compliance lens adds one question: what does each role do when its assumption fails?
Then decide, explicitly and in writing, what your interface does when a screening call returns a hit. The decision is a product and legal choice, and leaving it to whichever engineer wrote the integration is how protocols end up blocking the wrong users and documenting nothing.
References
Next, read On-Chain Identity 101 for how compliance and portable credentials are converging. More in Web3 Economics.