TON DeFi: Opportunities & Risks

Has the project been audited by a reputable security firm? Look for audit reports on the project's documentation or GitHub. Major firms auditing TON projects include CertiK, Quantstamp, and Trail of Bits.

Is the smart contract code publicly available? Closed-source contracts are a red flag — you cannot verify what they do with your funds.

Are the developers known and reputable? Anonymous teams are higher risk. Check their track record on previous projects.

How much total value is locked (TVL) in the protocol? How long has it been running? Newer protocols with low TVL are higher risk. Established protocols with significant TVL have more to lose from exploits.

If a protocol offers 1000% APY, ask where the yield comes from. Sustainable yields come from trading fees or lending interest. Unsustainable yields come from token emissions (printing new tokens), which dilute value over time.

Go: open a terminal in a folder you can write to, e.g. cd ~/Desktop (Windows: cd %USERPROFILE%\Desktop).

Do: save this as amm.py. It prints nothing; it is the exchange the next four steps trade against. There is no order book and no buyer on the other side — just a pool whose two balances must multiply to the same number after every trade.

class Pool:
    """A constant-product market maker: ton * jetton never falls."""
    def __init__(self, ton, jetton):
        self.ton, self.jetton = float(ton), float(jetton)

    @property
    def price(self):
        return self.ton / self.jetton

    def buy(self, spend_ton):
        k = self.ton * self.jetton
        got = self.jetton - k / (self.ton + spend_ton)
        self.ton += spend_ton
        self.jetton -= got
        return got

    def sell(self, jettons):
        k = self.ton * self.jetton
        got = self.ton - k / (self.jetton + jettons)
        self.jetton += jettons
        self.ton -= got
        return got

You should see: nothing at all. python3 amm.py returns you to the prompt, which means it parses.

If not: IndentationError means the methods lost their indent under class. If @property raises a syntax error, the decorator line must sit immediately above def price with nothing between.

Go: same folder.

Do: save this as impact.py and run it. Each line starts from an identical, untouched pool.

from amm import Pool

for spend in (10, 100, 1_000, 10_000):
    p = Pool(100_000, 100_000)
    fair = spend / p.price
    got = p.buy(spend)
    print(f"spend {spend:>6,} TON -> {got:>10,.1f} jettons "
          f"(a fair price would give {fair:>10,.1f}, so you lose {1 - got / fair:.2%})")

You should see: the cost of size:

spend     10 TON ->       10.0 jettons (a fair price would give       10.0, so you lose 0.01%)
spend    100 TON ->       99.9 jettons (a fair price would give      100.0, so you lose 0.10%)
spend  1,000 TON ->      990.1 jettons (a fair price would give    1,000.0, so you lose 0.99%)
spend 10,000 TON ->    9,090.9 jettons (a fair price would give   10,000.0, so you lose 9.09%)

This is price impact, and it is not a fee — it is the mathematics of the pool. Your own buying moves the price against you, and the loss grows with your size relative to the pool. It is the reason a thin pool is dangerous regardless of how honest the project is: the smaller the pool, the more a normal trade costs you.

If not: if every line shows the same loss, the pool is being reused instead of recreated — Pool(...) must be constructed inside the loop.

Go: same folder. Your pending trade is visible before it executes. A bot buys just before you and sells just after.

Do: save this as sandwich.py and run it.

from amm import Pool

victim_spend = 1_000

p = Pool(100_000, 100_000)
alone = p.buy(victim_spend)
print(f"if nobody interferes, you get   : {alone:,.1f} jettons")

p = Pool(100_000, 100_000)
attacker_jettons = p.buy(20_000)          # the attacker buys FIRST, pushing the price up
yours = p.buy(victim_spend)               # your order now fills at the worse price
attacker_ton = p.sell(attacker_jettons)   # the attacker sells straight after
print(f"sandwiched, you actually get    : {yours:,.1f} jettons")
print(f"you lost                        : {alone - yours:,.1f} jettons ({1 - yours / alone:.2%})")
print(f"the attacker put in 20,000 TON and took out {attacker_ton:,.1f}, "
      f"profit {attacker_ton - 20_000:,.1f} TON")

You should see: nearly a third of your purchase taken, legally, by arithmetic:

if nobody interferes, you get   : 990.1 jettons
sandwiched, you actually get    : 688.7 jettons
you lost                        : 301.4 jettons (30.44%)
the attacker put in 20,000 TON and took out 20,306.5, profit 306.5 TON

Nothing was hacked. The attacker used the same public exchange you did, in the same way, a moment earlier and a moment later. This is why a swap that looked fine when you pressed the button can settle far worse — and why the next step’s setting exists.

If not: if the attacker’s profit is negative, the sell is happening before your buy — the three calls must run in the order written.

Go: same folder. Every swap interface has a slippage tolerance, usually hidden behind a gear icon and usually left alone.

Do: save this as tolerance.py and run it. The attack from step 3 happens every time; only your floor changes.

from amm import Pool

victim_spend, expected = 1_000, 990.1

for tolerance in (0.005, 0.01, 0.05, 0.30, 0.50):
    p = Pool(100_000, 100_000)
    p.buy(20_000)                                   # attacker front-runs
    got = p.buy(victim_spend)
    minimum = expected * (1 - tolerance)
    verdict = "FILLED" if got >= minimum else "REVERTED -- your funds stay put"
    print(f"slippage tolerance {tolerance:>5.1%}: you would receive {got:>7,.1f}, "
          f"floor {minimum:>7,.1f}  -> {verdict}")

You should see: the protection working until you switch it off yourself:

slippage tolerance  0.5%: you would receive   688.7, floor   985.1  -> REVERTED -- your funds stay put
slippage tolerance  1.0%: you would receive   688.7, floor   980.2  -> REVERTED -- your funds stay put
slippage tolerance  5.0%: you would receive   688.7, floor   940.6  -> REVERTED -- your funds stay put
slippage tolerance 30.0%: you would receive   688.7, floor   693.1  -> REVERTED -- your funds stay put
slippage tolerance 50.0%: you would receive   688.7, floor   495.1  -> FILLED

Read the last line carefully, because it is the most common self-inflicted loss in DeFi. A swap that keeps failing tempts people to raise the tolerance until it goes through — and a high tolerance is an instruction to accept any price down to that floor. If a swap fails at 1%, the honest reading is that the pool is too thin for your size or somebody is waiting for you, and the answer is a smaller trade, not a bigger allowance.

If not: if every line says FILLED, the minimum comparison is inverted — the trade fills only when what you receive is at or above the floor.

Go: same folder, beside tonaddr.py.

Do: save this as identity.py and run it. On TON a token is a jetton, and its identity is the address of its minter contract — not its name, which anybody may copy.

import hashlib
from tonaddr import encode

def jetton_address(minter_name):
    """A jetton's identity is its MINTER contract address, never its name or symbol."""
    return encode(hashlib.sha256(minter_name.encode()).digest())

real = jetton_address("official-usdt-minter")
fake = jetton_address("copycat-usdt-minter")

print("both tokens display the same name and symbol: USDT")
print("the one in the official list :", real)
print("the one the swap page linked :", fake)
print("same token:", real == fake)

You should see: two entirely different tokens wearing one name:

both tokens display the same name and symbol: USDT
the one in the official list : EQANPe5J8_ntdEoqZklA9p0LaK9thJO4S5qZiGLOvJpEw74F
the one the swap page linked : EQBgf-LvUCwVuaVed8cR7PaJ2o6KRMAAc5RIz1AJFy5mK5qK
same token: False

Creating a jetton called USDT with the same logo costs almost nothing, and a swap link can point at it. Your wallet will show the name it was given. Before a first swap into any token, compare the minter address in the swap interface against the address published by the project itself — on their own site or in the exchange’s verified list — character by character at both ends. Do it once per token; after that your wallet remembers.

If not: ModuleNotFoundError: No module named 'tonaddr' means the file from the introduction tutorial is not in this folder. Your two addresses will differ from the ones above only if the quoted minter names were changed.