Smart Contract Exploit Registry

The TON Smart Contract Exploit Registry is a durable, source-aware record of critical vulnerabilities and exploits specific to the TON Virtual Machine (TVM) and its actor-based execution model. Unlike EVM chains where atomic transactions are the norm, TON's architecture relies on asynchronous message passing between smart contracts, creating a distinct class of attack vectors. This registry catalogs real-world incidents involving FunC and Tact code, focusing on replay attacks on internal messages, race conditions in non-atomic cross-contract calls, and DeFi logic bugs that have led to the loss of user funds or protocol insolvency.

Each entry in this registry dissects the vulnerable code pattern, the precise exploit mechanics used by the attacker, and the resulting on-chain impact. The analysis extends beyond simple reentrancy to cover TON-specific pitfalls such as mishandling of bounce flags, incorrect parsing of message bodies in recv_internal, and state manipulation across shard boundaries. For developers and auditors, the registry serves as a practical adversarial knowledge base, translating post-mortem findings into concrete, actionable mitigation strategies—such as implementing strict message sender validation, using carry-value patterns correctly, and designing atomicity guards for multi-contract interactions.

For protocol architects, risk teams, and custodians, this registry provides the technical context needed to evaluate the security posture of TON-based DeFi protocols, wallets, and token contracts. Understanding these exploit patterns is essential for performing thorough integration risk assessments and for building monitoring systems that can detect anomalous asynchronous call flows. The registry connects each incident to broader operational implications, including the challenges of pausing or upgrading non-atomic contract systems during an active exploit.

Chainscore Labs supports teams in hardening their TON smart contracts against these documented exploit patterns through deep-dive code reviews, adversarial testing of asynchronous call graphs, and the design of incident response mechanisms tailored to TON's unique execution environment. If your team is building or integrating with TON DeFi protocols, our protocol impact assessments can help identify and remediate these risks before they lead to a critical incident.

The TON blockchain executes smart contracts as independent actors that communicate exclusively through asynchronous message passing. Unlike Ethereum's atomic transaction model where a sequence of contract calls either fully succeeds or fully reverts, a TON transaction is a single message delivery that triggers a single contract execution. A user action that interacts with multiple contracts—such as a DeFi swap—is decomposed into a chain of separate, non-atomic messages. This means state changes across contracts are not guaranteed to be consistent, and an attacker can intentionally craft messages that arrive between these steps to observe and manipulate intermediate states. This fundamental architectural difference is the root cause of most TON-specific exploit patterns.

Key vulnerability classes emerge directly from this model. Reentrancy-by-message occurs when a contract sends a message to an untrusted contract and continues execution before the response arrives, allowing the callee to call back into the original contract in a subsequent transaction. Race conditions in asynchronous calls arise when a contract's state depends on the order of incoming messages from multiple sources, which an attacker can influence by carefully timing their own messages. Bounceable message handling flaws are unique to TON: if a message is sent with the bounce flag and the recipient rejects it, the sender receives a bounced message with the original value. Contracts that fail to correctly handle these bounce messages can be drained or left in an inconsistent state. The Smart Contract Exploit Registry catalogs real-world incidents where each of these patterns led to fund loss.

For developers and auditors, the operational implication is that standard EVM security checklists are insufficient. A TON contract must be verified to be secure under all possible message interleavings, not just within a single atomic execution context. This requires modeling the contract as a state machine and proving that no sequence of external messages can lead to an invariant violation. Chainscore Labs provides specialized review engagements for FunC and Tact contracts that apply this actor-model threat modeling, helping teams identify replayable message sequences, missing bounce handlers, and cross-contract state corruption risks before deployment.