The TON blockchain ecosystem has introduced an innovative extension to the Jetton standard called Mintless Jettons. This extension enables decentralized, Merkle-proof airdrops without the need for traditional minting processes. In this post, we'll explore what Mintless Jettons are, why they're needed, and how they can be supported across smart contracts, wallet applications, and decentralized applications (dApps). We'll also delve into deploying a Mintless Jetton and auditing the airdrop balances.
Mintless Jettons are an extension of the standard Jetton implementation on the TON blockchain. They allow for large-scale, decentralized airdrops to millions of users without incurring significant costs or adding excessive load to the blockchain.
- 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 immediately have their jettons ready to use—send, swap, and so on—without any preparatory steps like withdrawal or claim. It just works!
Since Mintless Jettons are an extension of Standard Jettons, no additional steps are needed. Just interact with them as you would with USDT, NOT, Scale, or STON.
Wallet applications play a crucial role in enhancing 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: On initiating an outgoing transfer, the wallet should automatically include the necessary Merkle proof in the
transfermessage's custom payload.
This can be done by either:
-
Integration with the Off-Chain API Specified in the Custom Payload API:
- For each jetton, check whether it is mintless.
- If it is mintless, check whether the owner of the wallet has claimed it.
- If not claimed, retrieve data from the Custom Payload API and add the off-chain balance to the on-chain one.
- On outgoing transfers, if the user has not yet claimed the airdrop, retrieve the custom payload and init state from the Custom Payload API and include it in the
transfermessage to the jetton wallet.
-
Custom API:
- Download the tree of airdrops from
mintless_merkle_dump_uriin the jetton metadata. - Parse it (see section 6 below) and make the parsed result available via API.
- Download the tree of airdrops from
Note that supporting Mintless claims (in particular, indexing of airdrop trees) is not mandatory for wallets. It is expected that wallet applications may charge the jetton issuer for this service.
Since the claim happens automatically in wallet applications, dApps don't need any specific logic. They may use APIs (like Tonapi or Toncenter) that show unclaimed balances.
To enhance the user experience, dApps can check whether the wallet application that the user used to connect to the dApp supports the specific mintless jetton. If it is not supported, the dApp can retrieve the airdrop proof and initialization data from the jetton API and add it to the transfer message on the dApp side.
Deploying a Mintless Jetton involves several steps:
-
Prepare the Merkle Tree:
- Generate a Merkle tree containing all the airdrop recipients and their respective amounts.
- Compute the root
merkle_hash.
-
Deploy the Jetton Master Contract:
- Include the
merkle_hashin the contract's storage. - Ensure the contract complies with the extended Jetton standard; you may use the Mintless Jetton Standard Implementation as an example.
- Include the
-
Provide the Merkle Proofs:
- Host the Merkle tree data off-chain.
- Implement the Custom Payload API to allow wallets to fetch the necessary proofs.
-
Update Metadata:
- Add the
mintless_merkle_dump_uriandcustom_payload_api_urito the token's metadata as per the Metadata Standard.
- Add the
-
Request Support from Wallets:
- Ask desired wallet applications to support (index) your Mintless Jetton.
By following these steps, you can deploy a Mintless Jetton that users can seamlessly claim during usual operations.
Auditing the airdrop and verifying the total supply consists of a few steps.
-
Accessing the Merkle Dump:
- Start by downloading the Merkle tree data from the
mintless_merkle_dump_uriprovided in the metadata. It can be stored in TON Storage, IPFS, a web 2.0 resource, or other ways. This file containsHashMap{address -> airdrop_data}as a BoC file. Theairdrop_dataincludes the amount, Unix timestamp from which the claim is available (start_from), and Unix timestamp when the claim is closed (expired_at).
- Start by downloading the Merkle tree data from the
-
Checking Integrity:
- This can be done by comparing the mintless Merkle dump cell hash with the hash stored in the jetton minter (the latter can be retrieved on-chain via the
get_mintless_airdrop_hashmap_rootget-method of the minter contract).
- This can be done by comparing the mintless Merkle dump cell hash with the hash stored in the jetton minter (the latter can be retrieved on-chain via the
-
Verifying Balances:
- Use the Merkle tree to verify individual balances and ensure they sum up to the expected total supply.
There are a few utilities that can be used for the steps described above.
-
Compile the Utility:
git clone https://github.com/ton-blockchain/toncd tongit checkout testnetmkdir build && cd buildcmake ../make mintless-proof-generator- The compiled file is stored as
build/crypto/mintless-proof-generator.
-
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.
-
Compile the Utility:
git clone https://github.com/tonkeeper/mintless-toolbox.gitcd mintless-toolboxmake
-
Run a Check:
./bin/mintless-cli dump <airdrop-filename>- This utility reads an airdrop file and dumps 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.
Mintless Jettons offer an efficient and scalable solution for large-scale token airdrops on the 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 experience for users and fosters wider adoption. Deploying and auditing Mintless Jettons involves careful implementation of Merkle trees and adherence to the extended standards, contributing to a robust and transparent token ecosystem.
References:
🚀🚀