Smart contracts — the little programs that run on blockchains like Ethereum and manage billions of dollars in digital assets — have a transparency tradition. To prove they're not doing anything sneaky, projects publish their source code on public block explorers and cryptographically verify that this source matches the compiled bytecode actually running on-chain. For years, this openness has been considered a security feature: anyone can audit the code before trusting it with their money.

This paper argues that openness has quietly become a liability. The reason is LLM agents. Attackers can now point a language-model-driven scanner at every verified contract on a blockchain and, in bulk, hunt for exploitable bugs at a scale no human auditor could match. The very thing that lets defenders inspect code also lets automated adversaries triage the entire ecosystem for prey.

The authors' response is clever, and a little counterintuitive: instead of hiding source code (which would break trust), they propose poisoning the source that gets published so that LLM scanners get confused, while human readers and the actual on-chain bytecode remain unaffected. Think of it as camouflage that only fools machines.

Concretely, they build a defense that:

• Rewrites the published source using transformations that preserve the compiled bytecode — so the on-chain program is byte-for-byte identical and still passes verification.
• Adds structures that mislead LLM-based analyzers — for example, code patterns that look vulnerable to a scanner but aren't actually reachable, or reorganizations that make an LLM's reasoning go off the rails.
• Keeps things readable enough for humans that legitimate auditors can still make sense of the contract.

The key insight is that LLMs and humans read code very differently. LLMs are pattern-matchers that get anchored on surface-level cues (function names, control-flow shapes, familiar idioms). Humans reason about intent and follow data flow. That gap creates room for defensive transformations that are adversarial to LLMs specifically — a new twist on the older idea of adversarial examples, but applied to code understanding instead of image classification.

The broader takeaway is a shift in how we should think about the smart contract disclosure model. When your adversary can afford to LLM-scan every contract ever deployed, "security through transparency" needs new machinery. The paper is an early attempt to give defenders a knob that doesn't require abandoning verifiability altogether.