Skip to main content

Mintless jettons processing

Introduction​

info

To understand this document, you should be familiar with the basic principles of asset processing outlined in payments processing section and jetton processing.

TON has introduced mintless jettons, an innovative extension of the Jetton standard.

This extension enables decentralized, merkle-proof airdrops without requiring traditional minting processes.

Overview​

Mintless jettons are an extension (TEP-177 and TEP-176) of the standard jetton implementation (TEP-74) on TON Blockchain.

This implementation enables large-scale, decentralized airdrops to millions of users while minimizing costs and blockchain load.

Basic features​

  • Scalability: Traditional minting processes can be resource-intensive and costly when distributing tokens to a vast number of users.
  • Efficiency: By utilizing merkle trees, mintless jettons store a single hash representing all airdropped amounts, reducing storage requirements.
  • User-friendly airdrops: Users receive jettons immediately, ready for transactions like sending and swapping—without needing to withdraw or claim them first.

Supporting mintless jettons in on-chain protocols​

Because mintless jettons extend the standard jettons, you can interact with them the same way you would with USDT, NOT, Scale, or STON—no additional steps required.

Supporting mintless jettons in wallet applications​

Wallet applications play a key role in improving the user experience with mintless jettons:

  • Display unclaimed jettons: Wallets should show users the jettons they are eligible to claim based on the merkle tree data.
  • Automated claim process: When users initiate an outgoing transfer, wallets should automatically include the necessary merkle proof in the transfer message's custom payload.

Wallets can achieve this by:

Integrating with the off-chain API specified in the custom payload API:

  • Check if the jetton is mintless.
  • Verify whether the wallet owner has claimed it.
  • If unclaimed, retrieve data from the custom payload API and add the off-chain balance to the on-chain one.
  • If the user hasn’t claimed the airdrop, retrieve the custom payload and initialization data from the Custom Payload API and include it in the transfer message to the jetton wallet.

Using a custom API:

  • Download the airdrop tree from mintless_merkle_dump_uri in the jetton metadata.
  • Parse the data as explained in section 6 below.
  • Make the parsed result available via API.
info

Wallets are not required to support mintless claims, including indexing airdrop trees. Wallet applications may charge the jetton issuer for this service.

Supporting mintless jettons in dApps (DEX/Lending platforms)​

Because wallet applications handle claims automatically, dApps don’t need special logic for mintless jettons. dApps can use APIs (such as TonAPI or Ton Center API) to display unclaimed balances.

To improve the user experience, dApps can check if the user's wallet application supports a specific mintless jetton. If unsupported, retrieve the airdrop proof and initialization data from the jetton API and include it in the transfer message.

Deploy a mintless jetton​

Deploying a mintless jetton involves several steps:

  1. Prepare a merkle tree:
  • Generate a merkle tree with all airdrop recipients and their respective amounts.
  • Compute the root merkle_hash.
  1. Deploy a jetton master contract:
  1. Provide merkle proofs:
  • Host the merkle tree data off-chain.
  • Implement the custom payload API to allow wallets to fetch the necessary proofs.
  1. Update metadata:
  • Add mintless_merkle_dump_uri and custom_payload_api_uri to the token's metadata as per the metadata standard.
  1. Request support from wallets:
  • Ask wallet applications to index your mintless jetton.

By following these steps, you can deploy a mintless jetton that users can seamlessly claim during regular transactions.

Retrieving airdrop information​

Auditing the airdrop and verifying the total supply involves a few steps.

Accessing the merkle dump​

  • Download the merkle tree data from the mintless_merkle_dump_uri in the metadata. It can be stored in TON Storage, IPFS, a web 2.0 resource, or other formats. This file contains HashMap{address -> airdrop_data} as a BoC file. The airdrop_data includes the amount, Unix timestamp from which the claim is available (start_from), and Unix timestamp when the claim expires (expired_at).

Checking integrity​

  • Compare the mintless merkle dump cell hash with the hash stored in the jetton minter. You can retrieve the latter on-chain using the get_mintless_airdrop_hashmap_root get-method of the minter contract.

Verifying balances​

  • Use the merkle tree to confirm individual balances and ensure they add up to the expected total supply.

Tooling​

Several utilities can help with these processes.

mintless-proof-generator (from Core)​

  1. Compile the utility:
git clone https://github.com/ton-blockchain/ton
cd ton
git checkout testnet
mkdir build && cd build
cmake ../
make mintless-proof-generator
  • The compiled file is stored as build/crypto/mintless-proof-generator.
  1. Run a check:
build/crypto/mintless-proof-generator parse <input-boc> <output-file>

This utility will print the mintless merkle dump cell hash and store to <output-file> the list of all airdrops in <address> <amount> <start_from> <expired_at> format (one airdrop per line).

You can additionally generate all merkle proofs (needed for custom_payload_api_uri) via the mintless-proof-generator make_all_proofs <input-boc> <output-file> command.

mintless-toolbox (from Tonkeeper)​

  1. Compile the utility:
git clone https://github.com/tonkeeper/mintless-toolbox.git
cd mintless-toolbox
make
  1. Run a check:
./bin/mintless-cli dump <airdrop-filename>
  • This utility reads an airdrop file and prints it to the console in the format: address,amount,start_from,expire_at.

By auditing the merkle tree and contract data, stakeholders can verify the integrity of the airdrop and token supply.

Conclusion​

Mintless jettons provide an efficient and scalable solution for large-scale token airdrops on TON Blockchain. By extending the standard jetton implementation, they reduce costs and blockchain load while maintaining security and decentralization.

Supporting mintless jettons across smart contracts, wallet applications, and dApps ensures a seamless user experience and drives adoption. Deploying and auditing mintless jettons requires careful implementation of merkle trees and compliance with extended standards, contributing to a transparent and robust token ecosystem.

See also​