TON Development: Smart Contracts, TON Connect & Back-end

TON Development: Architecture and Implementation

TON is not just a blockchain with fast transactions. The architecture with infinite sharding and the actor model imposes strict constraints on smart contract and back-end design. If you transfer approaches from EVM, you'll run into issues with parallel requests and bounce messages on mainnet. For instance, in one project we faced implementing a DEX with atomic swaps — due to the asynchronous model we had to switch to escrow contracts, saving months of development.

We build TON applications end-to-end. Our team has 5+ years of experience in blockchain and 20+ completed TON projects, covering the full cycle: from design to deployment and monitoring. We'll estimate your project in 1-2 days — just contact us.

How TON Architecture Affects Application Development

In TON, every smart contract is an actor. Messages are processed sequentially within a contract, but in parallel across different contracts. There is no global state, no synchronous calls. Instead, messages have a 1-2 block delay. This means atomicity of complex operations requires the commit-confirm-rollback pattern:

1. Contract A locks a preliminary state and sends a request to Contract B.
2. B processes the request and sends a confirm or reject.
3. A receives the response and finalizes or rolls back the state.

Bounce messages are critical: if B returns an error, the bounced message goes back to A. If A lacks a handler, funds can get stuck. Proper bounce handling reduces risk by 90%.

Smart Contracts: FunC vs Tact, When to Use What

For most tasks we use Tact — strict typing, built-in checks, readable syntax. Jetton (TEP-74), NFT (TEP-62), custom business logic — all in Tact. Compared to FunC, Tact cuts development time by 30–50% (2x faster).

FunC is for maximum gas optimization or non-standard cell layout work.

We use standard audited templates (Jetton Minter + Wallet) from TON Foundation. This reduces audit costs by 70% (from $10,000 to $3,000).

Why Store Data in Child Contracts?

TON charges storage fees for data storage. If a contract accumulates all user data in one place, it quickly depletes its balance and freezes. The correct pattern: master contract + per-user contracts (like jetton minter + jetton wallet). This reduces storage fees by orders of magnitude compared to a monolithic contract, saving up to $5,000 per month for a high-load dApp.

How to Integrate TON Connect?

TON Connect 2.0 is the protocol for connecting wallets (Tonkeeper, MyTonWallet, Tonhub). Integration via @tonconnect/sdk or @tonconnect/ui-react. Step-by-step:

1. Install the package: npm install @tonconnect/sdk.
2. Create a TonConnect instance with app settings.
3. Call connector.connect() to display a QR code.
4. Handle the onStatusChange event to get the wallet address.
5. Use connector.sendTransaction() to sign transactions, verifying the result via polling.

import { useTonConnectUI } from '@tonconnect/ui-react';

const [tonConnectUI] = useTonConnectUI();

const sendTransaction = async () => {
  const result = await tonConnectUI.sendTransaction({
    messages: [{
      address: contractAddress,
      amount: toNano('0.05').toString(),
      payload: beginCell()
        .storeUint(0x1234, 32)
        .storeAddress(userAddress)
        .endCell()
        .toBoc()
        .toString('base64')
    }]
  });
};

Back-end and Event Indexing

TON has no event logs. Transactions are read via TON HTTP API or tonapi.io. For production, we use tonapi.io — reliable, with high rate limits and webhooks. For custom indexing, we build our own indexer based on ton-index-worker or managed solutions (TONX, GetBlock). We write data to PostgreSQL and build the API on Node.js/FastAPI. This handles up to 10,000 requests per second.

Front-end: Stack and Specifics

The EVM stack doesn't work for TON. We use:

• @ton/core, @ton/ton
• @tonconnect/ui-react
• Telegram Mini App (TMA) via @telegram-apps/sdk

TMA is the primary pattern for mass-market applications. Contact us to discuss your project and get a commercial proposal.

What's Included in the Work

• Architecture design (message flow diagram, storage model)
• Smart contract development and testing
• Back-end deployment (API, indexer)
• Front-end with TON Connect
• Mainnet deployment and monitoring
• Documentation and source code delivery
• Post-launch support (optional)

Development Process

Final timelines for a full TON application: 2-4 weeks depending on complexity. Order development — we'll calculate exact timelines and cost in 1-2 days.

Typical Mistakes

• Ignoring bounce. Handle bounced messages in every contract that sends funds.
• Storing everything in one contract. Use per-user contracts.
• Not accounting for storage fees. Build in a replenishment mechanism.

We have ready-made solutions and templates to accelerate development. Get a consultation — we'll answer all your questions. Our proven experience guarantees delivery on time and within budget.

Smart Contract Development

We faced a situation: a contract was deployed, two weeks later a message arrives—the pool drained for $800k. Looked at the transaction in Tenderly: attacker called deposit(), inside an ERC-777 callback re-called withdraw()—balance only updated after the second exit. Classic reentrancy, but not via ETH transfer—through an ERC-777 hook. ReentrancyGuard was only on withdraw().

Such cases are not rare. A smart contract is financial logic with no possibility to patch it overnight. Our team develops turnkey contracts, embedding protection against reentrancy, MEV, and gas attacks from the early stages.

How We Develop Smart Contracts Turnkey

We start with business logic audit and stack selection. Solidity 0.8.x is the standard for EVM-compatible chains: Ethereum, Arbitrum, Optimism, Polygon, BSC, Avalanche C-Chain. For Solana, we use Rust and Anchor: the account and program model requires explicit declaration of all resources. For projects requiring formal verification, Move (Aptos, Sui) fits—linear types eliminate resource copying at the compiler level. Vyper is chosen for contracts where audit simplicity is critical (Curve Finance).

Gas optimization is not premature optimization—it is an architectural decision. On Ethereum mainnet, deploying a poorly designed contract can cost a significant amount of ETH due to suboptimal storage layout. Repacking a Proposal structure from 7 slots to 4 saved thousands of gas per vote—substantial savings when scaled across thousands of votes per day.

Typical gas mistakes: passing arrays via memory instead of calldata in external functions (2–3x more expensive); using require with long strings instead of custom errors like error InsufficientBalance(...). Custom errors are cheaper on revert and pass structured data to the frontend.

Why Smart Contract Audit Is Critical for Security

Audit is not a one-time check—it is a built-in development stage. We use three levels:

1. Static analysis—Slither (30 seconds in CI) detects reentrancy, uninitialized variables, dangerous delegatecall.
2. Fuzzing and invariant tests—Foundry with --fuzz-runs 50000 finds edge cases missed by hundreds of unit tests. Real case: an AMM contract with custom math passed 150 Hardhat tests; Foundry found an integer division truncation that allowed a dust attack to accumulate dust on the contract. Echidna checks invariants ("sum of all balances ≤ totalSupply").
3. Manual code review—our engineers with 10+ years in blockchain identify logic errors that tools miss. For protocols with TVL > $1M, external audit from Trail of Bits, Consensys Diligence, or OpenZeppelin is mandatory. Timeline: 2–4 weeks.

Any upgradeable protocol must have a timelock. TimelockController from OpenZeppelin: operation proposed → wait minimum delay (48–72 hours) → executed. Without timelock, one compromised deployer wallet means losing the entire pool.

What Upgrade Patterns Do We Choose?

Storage collision is the main danger of proxies. Implementation v2 must not add variables before existing ones. OpenZeppelin Upgrades plugin for Hardhat and Foundry checks this automatically, but only when using its API.

How to Protect a Contract from MEV and Front-Running

On Ethereum mainnet, transactions in the mempool are visible to all. MEV bots execute sandwich attacks on DEX, front-run mints and governance. Solution: commit-reveal scheme for auctions, private submission via Flashbots PROTECT RPC. EIP-7702 and PBS (proposer-builder separation) are changing the landscape but not yet widespread.

What Is the Development Process?

1. Analysis—functional specification, call diagram, edge case analysis. Without this, coding starts in vain.
2. Development—Solidity/Rust with tests in parallel. Test → code → refactoring. Use Foundry for fuzz and invariant tests.
3. Internal audit—Slither + Echidna + manual code review. Foundry invariant tests for protocol invariants.
4. External audit—for projects with real money. Timeline: 2–4 weeks.
5. Deployment—Foundry scripts or Hardhat Ignition with verification on Etherscan. Gnosis Safe for ownership transfer immediately after deployment.
6. Monitoring—Tenderly alerts, OpenZeppelin Defender, Forta Network.

What Is Included

• Architecture documentation and contract specification (NatSpec).
• Source code with repository and CI (Slither, Foundry, coverage).
• Deployed contract with verification on blockchain explorer.
• Audit results (internal and external upon request).
• Access to monitoring and management (Gnosis Safe).
• Code warranty: critical bug fixes within one month after deployment.
• Consultation on web integration (wagmi, RainbowKit).

Estimated Timelines

• ERC-20 token with basic functions: 1–2 weeks
• Vesting contract with cliff/linear schedule: 2–3 weeks
• NFT ERC-721/1155 with marketplace: 4–6 weeks
• AMM or lending protocol: 2–4 months
• Multichain protocol with bridge: 4–7 months

Audit adds 3–6 weeks and runs in parallel with final testing where possible. Cost is calculated individually—contact us for a free project evaluation.

Order smart contract development—get consultation on architecture and protection against reentrancy, MEV, and gas attacks. Want to discuss details? Write to us—we will select the optimal stack for your task.