Flashloans on TON: Are They Available in 2026

A flashloan is an unsecured loan with the condition of atomic repayment in the same transaction. On Ethereum it’s a foundational DeFi primitive: Aave, Balancer, MakerDAO PSM, and dozens of protocols offer instant loans for arbitrage, liquidations, collateral swaps, and complex DeFi strategies. Monthly turnover runs into billions of dollars.

On TON it’s different. The network’s architecture — asynchronous messages instead of atomic transactions — breaks the core assumption of an Aave-style flashloan: “either the whole sequence executes, or it reverts.” This article covers what is actually available in 2026, which patterns protocols use, and which scenarios still work.

What flashloans are: a primer

Standard EVM flow:

1. User calls the flashloan provider’s contract.
2. The contract transfers X (say 1M USDT) — no collateral.
3. Within the same transaction the user does whatever they want: arbitrage, liquidation, collateral swap.
4. By the end of the transaction the user must return X + fee (usually 0.05–0.09%).
5. If return doesn’t happen, the entire transaction reverts and nothing was actually moved.

The magic is EVM-transaction atomicity: all or nothing. The primitive enables things that otherwise require real capital.

Why this doesn’t work out-of-the-box on TON

TON’s architecture breaks atomicity:

• Messages instead of transactions. You don’t send “one transaction” to a smart contract. You send an internal message that spawns further messages. Each executes in its own block, often on different shards.
• No global rollback. If step three of a chain fails, the first two already happened — their messages are committed on-chain. You can’t undo them.
• Bounce messages as compensation. TON supports bounce — returning a message to the sender flagged as error. This gives the originating contract a chance to compensate, but requires explicit commit/revert logic.
• Gas distributed. Each internal message requires its own forward fee. Multi-step logic costs more than a single EVM call.

Consequence: the classic Aave-flashloan “give 1M USDT and check return at end of transaction” can’t be implemented directly. You need a model where the lending contract tracks the chain itself and applies penalties if return doesn’t arrive on time.

i

Technical note. TON has the RESERVE opcode and built-in bounce semantics — enough to build “deferred-atomic” credit contracts. But it’s not free: the borrower must be a cooperating smart contract that honors a commit/revert protocol, not an arbitrary EOA.

What’s actually available on TON in 2026

Snapshot as of May 2026:

1. EVAA Protocol — flashloan mechanic in docs. EVAA, the largest lending protocol on TON, references a flashloan capability among its primitives. At time of writing the actual depth of available liquidity and terms (fee, limits, supported assets) need fresh confirmation with the team — public integrations remain few.
2. Custom credit contracts for specific scenarios. Teams working on arbitrage or MEV-style activity deploy their own credit smart contracts: “contract A lends to contract B, and in the same message chain B must return, otherwise bounce + penalty.”
3. Intent-based schemes. A user signs an intent (“I want 100 USDT in TON terms”) and a solver network executes it with the solver’s own capital. Not strictly a flashloan but solves part of the same problem space (collateral swap, refinancing).
4. DAOlama leverage loops. For NFT-collateral strategies, DAOlama provides leveraged positions without requiring a separate flashloan — protocol-level logic handles the refinancing internally.

Key takeaway: “flashloans on TON” in 2026 is not an Aave-style open market but a set of protocol-specific and custom-built solutions.

What a TON flashloan could look like: deferred-finality pattern

A conceptual TON flashloan contract:

1. User sends message X with loan parameters and a signed callback.
2. The lender contract transfers the amount to address A (user-specified) and writes “debt” to storage with a TTL (say 60 seconds / N blocks).
3. Address A is a smart contract executing the business logic (swap, liquidation). On completion it must return funds with the unique loan ID.
4. On receipt of return the lender deducts fee, clears the debt.
5. If TTL expires without return — the contract initiates penalty actions: collateral seizure (if any), bounce notification, address blacklist.

This pattern works but imposes limits:

• The borrower must be a smart contract, not a plain EOA wallet.
• All participants in the chain must correctly handle messages and fees.
• TTL must account for cross-shard message propagation time.

Use cases on TON

Even with these constraints, flashloan-like tooling solves real problems:

Scenario	What flashloan does	Alternative without it
STON.fi ↔ DeDust arbitrage	Borrowed funds to catch spread without own capital	Use own capital, size-limited
EVAA liquidation defense	Short-term borrow to top up collateral / repay debt	Need extra capital or accept liquidation
Collateral swap	Borrow, repay debt, withdraw old collateral, post new	Full exit and re-entry only
One-click leveraged position close	Borrow → repay debt → unlock collateral → return	Manual multi-step management
Self-liquidation	Borrow to partially repay, avoiding full-liquidation penalty	Accept full liquidation with liquidator bonus

Each of these works on TON but requires either integration with a specific protocol or a custom flashloan contract.

TON-specific risks

A flashloan on an async chain isn’t just “EVM analog with a different SDK.” Specific pitfalls:

1. Failed inner messages. If step three of the chain fails due to gas shortage or logic error — steps one and two already happened. Without correct bounce/refund logic, funds sit in an intermediate state.
2. Cross-shard race conditions. Inter-shard messages have non-deterministic latency. A strategy assuming “buy on DEX A, immediately sell on DEX B” can find the second leg arrived seconds later than expected — by which time price moved.
3. Forward fees. Every message costs. A complex 10–15-message strategy can eat more in fees than the profit it generated.
4. Protocol-level risk. If the flashloan contract integrates with a lending protocol’s liquidity pool (EVAA) and that pool has a bug — the flashloan arbitrageur loses not just profit but also gas costs.
5. Verification difficulty. Auditing flashloan contracts on TON is harder than on EVM — async logic and cross-shard interactions open more attack angles.

!

The main user risk — integrating with an unaudited flashloan contract. On EVM, Aave has been audited dozens of times. On TON most solutions are custom-built without public audits. Before using one — read the code, check the team’s repo and comments, ideally via explorer-verified contracts.

What this means for users

Practical summary:

1. A retail user doesn’t need flashloans on TON in 2026. It’s a tool for arbitrage teams and developers, not the average DeFi user.
2. If you want leverage — use ready-made products: leveraged positions on DAOlama (NFT collateral), perp positions on Storm Trade, leveraged farming on STON.fi.
3. If you fear liquidation — EVAA and DAOlama offer collateral management tools (top-up, partial repay) without needing a flashloan.
4. If you’re a dev building an arbitrage bot — study EVAA’s flashloan docs, learn the custom-contract flashloan patterns, build bounce/refund logic into your architecture from day one.
5. Always test on testnet first. Async logic doesn’t forgive “hope it works” — testnet runs first, mainnet with minimal size second.

Comparison: TON vs EVM flashloans

Summary table:

Parameter	EVM (Aave, Balancer)	TON
Atomicity	Full (whole-tx revert)	Simulated via bounce + TTL
Liquidity	Billions USD, public	Limited, mostly protocol-specific
Fee	0.05–0.09%	Provider-dependent + forward fees
Supported assets	Dozens of tokens	TON, USDT, core jettons
EOA borrower	Yes	No, smart contract only
Audits	Mature, many	Weak, mostly custom
Integration complexity	Low	High (async logic)

EVM is a mature, open market. TON is a developing market focused on protocol-specific solutions.

Alternatives to flashloans: how TON solves the same problems differently

Even with flashloans constrained, the problems they solve on EVM still exist. The ecosystem finds workarounds:

1. Solver networks and intent-based DEXs. Instead of “I’ll borrow, operate, repay,” the user signs an intent (“I want X USDT in exchange for my collateral Y”) and solvers compete to fulfill it. The solver carries capital and risk; the user gets a result. This eliminates the flashloan need for conventional collateral swaps.
2. Within-one-contract atomic operations. If the entire business logic fits inside a single smart contract (e.g., leveraged loops on DAOlama), the protocol can arrange an “atomic” intra-contract sequence: one internal message does everything. Works for specific scenarios, not arbitrary composition.
3. Permissioned flashloans between whitelisted contracts. Some lending protocols may restrict flashloans to vetted integrators (whitelist of audited arbitrage strategies). Less open, but reduces poor-integration risk.
4. Cross-margin on perp DEXs. Storm Trade and peers let position margin act as “capital” for opening other positions — partially solving leveraged arbitrage without explicit borrowing.
5. Lending pool as arbitrage liquidity source. If you have an EVAA deposit, the protocol could in the future allow “temporary use” of your own deposit for an arbitrage strategy with guaranteed return — a flashloan / lending hybrid.

None of these covers all Aave-flashloan use cases, but collectively they cover most practical needs.

Cost of flashloans on TON vs EVM: economic breakdown

Comparing the cost of one flashloan operation (hypothetical arbitrage swap across two DEXs):

Parameter	Aave V3 (Ethereum)	Hypothetical TON flashloan
Provider fee	0.05% of notional	0.05–0.10% (provider-dependent)
Gas / forward fees per operation	$5–30 at peak	$0.10–0.30 (10–15 messages × forward fee)
Minimum profitable size	~$2,000–5,000	~$200–500
Integration complexity	Low (ERC-3156 standard)	High (custom async logic)

Interesting point: TON is CHEAPER on gas, but more expensive on “developer capital.” With existing infrastructure and solver bots, you get a lower size threshold for break-even. Starting from scratch, development and audit costs swallow the first months’ profits.

Conclusion

Flashloans on TON in 2026 aren’t a missing feature — they’re a different paradigm. The architecture doesn’t ship an easy Aave analog; instead, deferred-finality patterns, intent schemes, and protocol-specific flashloans inside lending platforms (EVAA first) are emerging.

For an average user this means: if you need leverage, use ready-made products like Storm Trade, DAOlama, EVAA. If you’re building arbitrage, design for async logic and rigorous failure-mode handling. If you integrate with someone else’s flashloan contract, demand an audit and verification.

And remember: on TON, “try without capital” via atomic flashloan isn’t as easy as on Aave. That’s both a plus (fewer exploit waves) and a minus (slower evolution of complex DeFi strategies).

→