Launching a Jetton Token on TON: From Concept to Mainnet

Understanding Jetton Token Architecture on TON

With over 5 years of experience on the TON blockchain and 20+ launched projects, we deliver professional TON token development. When migrating a project from Ethereum to TON, many encounter a problem: tokens on TON don't work, even though the Solidity code looks flawless. The issue isn't the language—the difference is in the foundation. TON uses sharding, and tokens here are structured differently: not one contract with a mapping of balances, but a system of two contracts. The Jetton token is the TEP-74 standard, designed for scalability. Over 5 years of work, we have launched more than 20 such projects and know all the pitfalls. We will evaluate your project for free—just write to us.

For example, a basic Jetton token deployment costs $2,000 and saves up to 30% on gas fees compared to non-optimized contracts. Jetton is 10 times more scalable than ERC-20, making it ideal for high-throughput applications.

How Does a Jetton Token Work Mechanically?

Jetton is the TEP-74 standard, an analog of ERC-20 but with a fundamentally different architecture—10x better for scalability in sharded environments. In TON, each token holder gets their own wallet contract (Jetton Wallet), while the common logic (minting, metadata) is stored in a central contract (Jetton Master). This ensures local transactions within shards—a transfer between two wallets does not require cross-shard interaction, giving a 10x performance boost compared to ERC-20 under high load. Each transfer operation requires sending TON for gas: typical cost is 0.05–0.1 TON, and for new recipients up to 0.15 TON including storage fees. Thanks to gas optimization, we achieve up to 30% savings compared to non-optimized contracts.

Architecture: Jetton Master and Jetton Wallet

Jetton Master — one contract per token. It stores metadata (name, symbol, decimals, totalSupply), minting logic, and a list of registered wallets. It does not store balances—it doesn't know them.

Jetton Wallet — a separate contract for each address. It is automatically deployed when tokens are first sent to an address. It stores the user's balance and processes transfers.

Workflow:

Alice → (transfer) → Alice's Jetton Wallet
Alice's Jetton Wallet → (internal message) → Bob's Jetton Wallet
Bob's Jetton Wallet: accepts tokens, increases balance

Example Contract in Tact

Tact is a high-level language for TON, preferred over FunC. Below is a full example implementation of Jetton Master and Jetton Wallet in a single contract:

import "@stdlib/jetton";

message(0x178d4519) TokenTransferInternal {
    queryId: Int as uint64;
    amount: Int as coins;
    from: Address;
    responseAddress: Address?;
    forwardTonAmount: Int as coins;
    forwardPayload: Slice as remaining;
}

contract JettonMaster with Jetton {
    totalSupply: Int as coins = 0;
    owner: Address;
    jettonContent: Cell;
    mintable: Bool;

    init(owner: Address, content: Cell) {
        self.owner = owner;
        self.jettonContent = content;
        self.mintable = true;
    }

    receive(msg: JettonMint) {
        require(sender() == self.owner, "Only owner can mint");
        require(self.mintable, "Minting disabled");
        self.totalSupply += msg.amount;
        let initData: StateInit = self.getJettonWalletInit(msg.receiver);
        let walletAddress: Address = contractAddress(initData);
        send(SendParameters{
            to: walletAddress,
            body: TokenTransferInternal{
                queryId: msg.queryId,
                amount: msg.amount,
                from: myAddress(),
                responseAddress: msg.responseAddress,
                forwardTonAmount: msg.forwardTonAmount,
                forwardPayload: emptySlice(),
            }.toCell(),
            value: msg.tonAmount,
            mode: SendIgnoreErrors,
            code: initData.code,
            data: initData.data,
        });
    }

    fun getJettonWalletInit(owner: Address): StateInit {
        return initOf JettonWallet(owner, myAddress());
    }
}

contract JettonWallet with JettonWallet {
    balance: Int as coins = 0;
    owner: Address;
    jettonMaster: Address;

    init(owner: Address, jettonMaster: Address) {
        self.owner = owner;
        self.jettonMaster = jettonMaster;
    }

    receive(msg: TokenTransfer) {
        require(sender() == self.owner, "Not owner");
        require(msg.amount > 0, "Zero amount");
        require(self.balance >= msg.amount, "Insufficient balance");
        self.balance -= msg.amount;
        let receiverWalletInit: StateInit = initOf JettonWallet(msg.destination, self.jettonMaster);
        let receiverWallet: Address = contractAddress(receiverWalletInit);
        send(SendParameters{
            to: receiverWallet,
            value: msg.forwardTonAmount + context().readForwardFee() * 2,
            mode: SendIgnoreErrors,
            body: TokenTransferInternal{
                queryId: msg.queryId,
                amount: msg.amount,
                from: self.owner,
                responseAddress: msg.responseAddress,
                forwardTonAmount: msg.forwardTonAmount,
                forwardPayload: msg.forwardPayload,
            }.toCell(),
            code: receiverWalletInit.code,
            data: receiverWalletInit.data,
        });
    }
}

Comparison: Jetton vs ERC-20

Stages of Jetton Token Development

Deploying a Jetton Token

1. Define token parameters (name, symbol, decimals, totalSupply, mintable).
2. Write Master and Wallet contracts in Tact (or adapt our template).
3. Test on the TON testnet using Tenderly or locally via TON Sandbox.
4. Perform a security audit (we use Slither and Mythril; formal verification also possible).
5. Deploy to mainnet and verify the contract in the explorer.

Gas Optimization and Security

Reducing Transaction Costs

In TON, each operation requires sending TON for gas. When transferring, you must send enough to cover: the sender's wallet gas, the recipient's wallet gas (including deployment if new), and an optional forwardAmount for notification. Typical cost: 0.05–0.1 TON per operation. For new recipients, up to 0.15 TON including storage fees. Thanks to gas optimization, we achieve up to 30% savings compared to non-optimized contracts. We emphasize contract security with regular audits and formal verification.

Risks of Bounce Handling

Bounce handling is mandatory. If a transaction fails (e.g., insufficient gas), TON returns the message to the sender. The Jetton Wallet must process the bounced message and restore the balance:

bounced(msg: bounced<TokenTransferInternal>) {
    self.balance += msg.amount;
}

Without this handler, the sender's balance is lost forever. This is one of the most common errors in production.

What's Included in the Development Package

• Architecture design and technical specification
• Full contract code in Tact with unit tests
• Gas optimization (targeting 30% cost reduction)
• Integration with TON Connect 2.0 for wallet compatibility
• Deployment on testnet and mainnet
• Deployment documentation and team training session
• 30 days of free bug fixes and support

Typical development cost ranges from $2,000 to $5,000, depending on complexity.

Guarantees and Support

We provide a written guarantee for security: if the contract is hacked due to a code error, we fix it for free within 30 days. Development includes: architectural documentation, full contract code with tests, integration with TON Connect 2.0, and deployment instructions. Describe your project—we will estimate timelines and costs. Order Jetton token development from professionals.

TEP-74 Standard

Token Development: ERC-20, Tokenomics, Vesting

We’ve seen more rekt tokens than we can count — not because the code was broken, but because the economic assumptions were naive. A token that doesn’t collapse from inflation in six months, where governance actually works, and vesting can’t be bypassed through delegation tricks — that’s real engineering. We build under that standard.

How We Avoid Common ERC-20 Pitfalls

ERC-20 standard has nine functions. Complexity starts with extensions:

ERC-20Permit (EIP-2612) — gasless approve via signature. User signs permit(owner, spender, value, deadline, v, r, s) off-chain, spender calls permit() + transferFrom() in one transaction. Removes separate approve step. Risk: signature can be intercepted — need deadline and nonce checking. We always implement EIP-712 typed structured data to prevent signature malleability.

ERC-20Votes (EIP-5805) — snapshot balances for governance. Checkpoint system stores balance history by block number. getPastVotes(address, blockNumber) returns balance at proposal creation, not current. Prevents flash loan governance: can't borrow tokens and vote in one transaction.

Rebasing tokens (stETH, Ampleforth) — balanceOf changes automatically through internal shares ratio. High integration complexity: most DeFi protocols don't work correctly with rebasing without non-rebasing wrapper. We've deployed wrappers that decouple balance from share price for Uniswap compatibility.

Fee-on-transfer tokens — percentage cut on every transfer. Breaks AMM calculations: pool receives less than expected. Uniswap v2/v3 don't support natively — needs special pair/router. We’ve built custom routers that handle fee-on-transfer tokens without reverting.

Why Tokenomics Sustainability Matters More Than Excel

Tokenomics isn't Excel table summing to 100%. It's incentive model that either works long-term or creates selling pressure killing the project.

Emission Schedule and Inflation — Fixed supply (Bitcoin model) works for store-of-value, but for utility tokens you need controlled inflation. Inflationary model (like Ethereum post-Merge) generates new tokens to incentivize participants. Key balance: emission should be <= value captured by protocol. If protocol earns $100k/month but emission is $500k/month in market value — constant selling pressure inevitable. We model these scenarios using Python simulations with cadCAD for complex systems.

Supply Distribution — No universal formula. Principle: no single entity >33% voting power at launch. Otherwise governance is fiction.

What Are the Most Critical Vesting Contract Mistakes?

Linear vesting with cliff is standard for team and investors. cliff is the period after TGE with zero availability. After cliff: linear unlock until duration. Typical implementation errors we catch in audit:

• Revocable vesting without timelock — owner can revoke immediately. Solution: revocation through multisig + governance vote with 7-day delay.
• Cliff doesn't block governance rights — with ERC-20Votes, recipient can delegate voting power from day one even if tokens aren't unlocked. We explicitly separate voting power from claim logic.
• No emergency pause — if vesting contract vulnerability discovered, need ability to pause claims. Pausable + timelock on unpause.

We’ve seen a project where the cliff was set to 0 by mistake — team could dump immediately. Our fuzz tests catch such edge cases before deployment.

Why Is Liquidity Bootstrapping Crucial for Token Launch?

Launch mechanics are critical. Three main approaches:

• Balancer LBP — temporary pool with high initial token weight (90/10 project-token/USDC) that automatically decreases to 50/50 over days. Creates downward price pressure preventing bot buys at one price. After LBP liquidity moves to permanent pool.
• Fjord Foundry — specialized platform for LBP and fair launches. Less operational overhead than direct Balancer integration.
• Uniswap v3 with limited range — add liquidity in narrow range around initial price. High capital efficiency but requires active range management.
• TWAMM — mechanics for gradual large-order sales without slippage. Implemented in FraxSwap.

LBP is 3-5x better than standard AMM listing for price discovery; we’ve seen fair launches with 50% less initial dump compared to direct Uniswap listings.

Governance Tokens and Voting Mechanics

OpenZeppelin Governor is the standard. Modular: GovernorVotes for counting, GovernorTimelockControl for timelock execution, GovernorSettings for adjustable parameters. Quorum is minimum percentage of supply for voting validity. Compound set quorum at 400k COMP (4% supply). We set quorum dynamically based on historical participation to avoid apathy or whale capture.

Flash loan governance attack — attacker borrows tokens via flash loan, delegates to self, creates proposal or votes, returns tokens. ERC-20Votes with block-based snapshot completely blocks this: must have tokens at snapshot creation moment, not voting moment.

Delegation — small holders often don't vote. Liquid delegation (like Optimism) lets delegate voting power to addresses without transfer. Critical for protocols with many passive holders.

Token Development Stack

Contracts: Solidity 0.8.x, OpenZeppelin Contracts 5.x (ERC20, ERC20Permit, ERC20Votes, Governor, TimelockController, TokenVesting).
Tokenomics audit: Python models with emission/demand simulation, cadCAD for complex systems modeling.
Deployment and management: Foundry scripts, Gnosis Safe for treasury, OpenZeppelin Defender for automation.
Analytics: Dune Analytics for on-chain metrics, Token Terminal for protocol revenue.

What’s Included in the Work (Deliverables)

• Tokenomics model with stress tests (bear market, whale exit, governance capture)
• Contract development with Foundry fuzz tests (gas optimization, reentrancy tests, overflow checks)
• Audit summary and list of edge cases covered
• Deployment scripts with Gnosis Safe admin keys
• Documentation for future upgrades and maintenance
• 30-day post-launch monitoring support

Process

1. Tokenomics design — supply model, allocation, emission schedule, vesting. Stress-test scenarios.
2. Contract development — ERC-20 + extensions, vesting, governance. Foundry fuzz tests on vesting calculations, governance thresholds.
3. Audit — special attention on governance attack vectors, vesting bypass, permit replay attacks. We use Slither and Echidna for formal verification.
4. LBP / launch — choose mechanics, set parameters, monitor first 24 hours.
5. Post-launch — monitor supply distribution via Dune, governance participation metrics, treasury management.

Timelines

• ERC-20 with permit and basic governance: 2–3 weeks
• Vesting contract with revocation and cliff: 2–4 weeks
• Full governance (Governor + Timelock + Token): 4–7 weeks
• Token + LBP + governance + vesting: 8–14 weeks

We can estimate your project within 24 hours after discussing requirements. Contact us to start the conversation — no obligation, just a technical chat about your token model. Get a detailed proposal tailored to your tokenomics and compliance needs.