ton development services: Building Jetton Tokens and Onchain Marketplaces on TON

7Block Labs: Your Go-To for Jetton Tokens

At 7Block Labs, we’re all about helping startups and enterprises launch top-notch Jetton tokens and on-chain marketplaces using the TON network. We leverage the latest standards--like TEP-74, TEP-64, TEP-89, Mintless Jettons, and Wallet V5--to make sure you can tap into Telegram-scale users, all while keeping things secure and user-friendly.

Here’s a handy playbook we’ve put together, packed with patterns, common pitfalls, and implementation checklists that you can start using right away. Check it out! (docs.ton.org)

Summary

A Practical Guide to Creating, Launching, and Growing Jetton-Based Products and Marketplaces on TON

This guide is here to walk you through the process of designing, launching, and scaling your Jetton-based products and marketplaces on TON. We’ll cover everything from shard-aware contract setups to using Wallet V5 for gasless transactions, ensuring safe decimal transfers, and keeping an eye on production with TonAPI. Plus, we’ll touch on handy build-time tools and essential security measures.

What You’ll Learn

• Jetton Basics: Understand what Jettons are and how they can benefit your project.
• Shard-Aware Contract Layouts: Get the lowdown on configuring your contracts so they play nicely across shards.
• Gasless Flows with Wallet V5: Discover how Wallet V5 can simplify user experience by enabling gasless transactions.
• Decimal-Safe Transfers: Learn how to ensure that your transfers handle decimals without a hitch.
• Production Monitoring via TonAPI: Find out how to keep track of your product's performance with TonAPI.
• Build-Time Tooling: Explore tools that can streamline your development process.
• Security Guardrails: Understand the security measures you should put in place to keep your marketplace safe.

By the end of this guide, you’ll have a solid foundation for building and scaling your Jetton-based projects on TON. Let's dive in!

---

Why TON in 2025: concrete advantages that matter for decision‑makers

• The shard-first architecture is all about making account activity run smoothly at scale. It lets contracts be nicely placed “close to” users, which helps cut down on cross-shard latency for those hot paths. Just a heads-up, those typical cross-shard hops can add around 12-13 seconds, so minimizing them is key. (docs.ton.org)
• Jettons (TEP‑74) roll out a distributed model where each holder gets their own wallet contract. This setup takes away the bottleneck of a single contract, paving the way for nearly linear scaling as your user base grows. (docs.ton.org)
• Wallet V5 is bringing in some cool features like signed internal messages and gasless patterns. Now you can do things like “pay fees in USDT,” send multiple transactions at once (up to 255 messages), and set up delegated actions. These changes are super crucial for making mainstream apps user-friendly. (docs.ton.org)
• TON Connect serves as the go-to wallet bridge for dApps and Telegram Mini Apps, which is awesome. Plus, you’ll find SDKs available in JS, Dart, Python, and more, making it quicker to get your clients up and running. (docs.ton.org)

---

Jettons, precisely: the standards you’ll actually use

• TEP‑74: This one covers the fungible token interface, which includes both the master wallet and per-holder wallets.
• TEP‑64: Here, we’ve got the metadata scheme that spans on-chain, semi-chain, and off-chain aspects, plus it includes details about decimals.
• TEP‑89: This TEP tackles wallet discovery, explaining how different apps and wallets can locate the per-user Jetton wallet. (docs.ton.org)

Key Implications for Your Build:

• Performance Boost: Upgrading certain components could really ramp up your system’s speed. Think about swapping out that old HDD for an SSD or adding more RAM. It’s amazing how much difference these small changes can make!
• Compatibility Check: Always double-check that everything plays nicely together. Before you buy new gear, make sure it fits with your current setup. It’s a bummer to discover something doesn’t work after you’ve spent the cash.
• Future-Proofing: Investing a bit more now can save you headaches later. If possible, aim for parts that will still be relevant a few years down the line. This way, you won’t have to overhaul everything again anytime soon.
• Cooling Solutions: Don’t overlook your cooling setup! As you add power, keep an eye on the temperatures. A solid cooling system can keep your components happy and running smoothly.
• Budget Considerations: Stick to your budget, but be flexible if something really catches your eye. Just because it’s on sale doesn’t mean you should buy it if it’s not what you need. Stick to the essentials first!
• Aesthetics Matter: If you care about how your build looks, start planning the layout and color scheme now. Cable management and lighting can really make a difference, but you’ll need to think about this in advance to pull off that clean look.
• Every time a user interacts, it directly interacts with their Jetton wallet contract instead of a global ledger. This means as more users join, your throughput increases too!
• Decimals are handled in metadata. Most Jettons come with 9 decimals, while USDT on TON sticks to 6. When you calculate the on-chain amount, remember to use display_amount × 10^decimals. Mess this up, and you could accidentally send 1000 times more than you intended. (docs.ton.org)

---

Picking the right Jetton implementation in 2025

• Jetton 2.0 (recommended): This version has smart wallet placement right in the same shard as the owner's wallet, which means faster response times and lower forward fees on those crucial hot paths. Check it out here: (docs.ton.org)
• Mintless Jetton (TEP‑177 + TEP‑176 API): Perfect for those airdrops to millions! This nifty feature mints "on demand" right into the recipient's wallet, so no more bottlenecks or chain overload during distribution. Learn more on GitHub: (github.com)
• Stablecoin/governance variant: If you're looking at a centralized stablecoin with admin controls, we've got reference contracts that are compatible with TEP‑74/89. Super handy for tokens needing to meet compliance standards. Dive in here: (github.com)

Decision tip: For most projects, we go with Jetton 2.0. If you’re looking to do some viral airdrops, layer TEP‑177 is the way to go. And remember, keep governance controls--like freeze/blacklist/mint caps--set aside for those regulated assets.

---

Architecture that scales: shard‑aware Jettons

• Make sure to place Jetton Wallets “close to” the owner’s Toncoin wallet. The new toolchains let you set toShard: { closeTo, fixedPrefixLength } when you’re deploying, which helps to align addresses in the same shard. Starting with an 8-bit prefix gives you a solid balance between control and brute-force efficiency. Check it out here.
• So, why does this matter? Well, cross-shard delivery depends on a MasterChain checkpoint, which means you can expect around 12 to 13 seconds of extra latency for each hop. To keep things running smoothly, it’s best to keep your critical flows within the same shard. For more info, visit this page: docs.ton.org.

Shard Checklist

Here’s a handy checklist to help you keep track of everything you need for your Shard setup.

Pre-Deployment Checklist

• Hardware Requirements: Ensure you meet the minimum hardware requirements.
• Software Dependencies: Confirm that all necessary software is installed.
• Network Configuration: Check your network settings to ensure connectivity.
• Backup Plan: Have a backup plan in place in case things go awry.

Deployment Checklist

• Install Shard: Follow the installation guide to get Shard up and running.
• Configuration Files: Edit your configuration files as needed.
• Test Connection: Make sure you can connect to your Shard instance.
• Initial Data Load: Load your initial data to get things started.

Post-Deployment Checklist

• Monitor Performance: Keep an eye on performance metrics.
• Regular Backups: Set up a schedule for regular backups.
• Update Software: Stay updated with the latest releases and patches.
• User Access: Ensure proper user access and security protocols are in place.

Feel free to refer back to this checklist whenever you’re getting ready to set up or maintain your Shard. Happy sharding!

• Break down "single points" like distributors into multiple child contracts.
• Steer clear of long synchronous chains across shards when it comes to user actions.
• Precompute where shards should be placed in tests to make sure we're getting the prefixes we want.

---

Metadata that won’t bite later: TEP‑64 in practice

• Go for semi‑chain metadata: keep the name, symbol, and decimals on-chain, while storing bigger assets off-chain using TON Storage. This way, you can keep those storage fees in check and still have the essential fields easily searchable on-chain. (docs.ton.org)
• Be sure to document your decisions on decimals (like using 6 for fiat-like and 9 for TON-like). Wallets pull decimals from the metadata, so avoid hardcoding them in your apps. (docs.ton.org)
• Use Snake data to encode long strings/JSON; don’t forget to budget your bits and cells to get a good estimate on storage costs. (docs.ton.org)

---

Transfers that always settle: decimals‑safe and comment‑aware

• Programmatic transfer: Make sure to set forward_ton_amount so the receiving Jetton wallet can handle the forwarded message. If you need to, toss in some comments in forward_payload. And don’t forget to grab the decimals before you start building the amount. (docs.ton.org)
• UX heads-up: Just a reminder, USDT only uses 6 decimals, so adjust your calculators and admin panels accordingly. And seriously, do some testing on the testnet with small amounts before moving to the mainnet. (docs.ton.org)

---

Distribution at scale: two battle‑tested patterns

1. Merkle Claim (Mintless Jetton TEP‑177)

• This approach lets you keep just one Merkle root on the blockchain, allowing users to claim their minting right into their Jetton wallet. It's super efficient for over a million recipients! Check it out on GitHub.

2) Console-managed claim airdrops

• To get started, use the Airdrop stack in Ton Console! Just upload a CSV file with the recipient information and the amount (in minimal units). Don’t forget to enforce the decimals--like for instance, 1 USDT should be 1,000,000 in minimal units. It's worth noting that recipients will need to pay a tiny TON fee to claim their airdrop. Your dApp can easily integrate this through TON Connect. For more details, check out the documentation here.

---

Wallet integration: TON Connect and Wallet V5 for enterprise UX

• TON Connect is the go-to connection protocol for Telegram Mini Apps. You can easily integrate it using @tonconnect/sdk (JavaScript) or the Dart/Python SDKs for your Flutter or backend setup. Don’t forget to host your manifest and list out the wallets you support. You have the option to use a hosted bridge or set up your own! Check out the details here.
• With Wallet V5, you can enjoy a gasless user experience! Just sign an internal message that includes two Jetton transfers--one for the recipient and the other for the relayer. Then, a service like TonAPI backend can handle the network fees in TON for you. It’s perfect if you want to “pay fees in USDT.” See more info here.

Implementation Notes

Here are some helpful notes and tips for implementing your project smoothly.

Setup

1. Install Dependencies
   Make sure you have all the necessary dependencies installed. You can do this by running:

   npm install

2. Configure Environment Variables
   Set up your environment variables in a .env file, following the example below:

   API_KEY=your_api_key_here
   DB_URL=your_database_url_here

Running the Application

To start up the app, just run:

npm start

This will spin up the server and you can access it at http://localhost:3000.

Testing

Don’t forget to run your tests! It's super easy--just use:

npm test

Troubleshooting

If you hit any bumps along the way, here are a few common issues and their fixes:

• Issue: Application won’t start
  Fix: Double-check your environment variables and ensure all dependencies are installed.
• Issue: Tests are failing
  Fix: Look at the error messages closely; they usually give good hints about what's wrong.

Resources

• Official Documentation
• Community Forum

Take your time to go through each section, and you’ll be all set up in no time!

• Handle seqno races for gasless relays and blacklist any requests that are stuck or conflicting, following the guidance from the V5 repo.
• Let users choose their fee tokens, but if the Jetton balance isn’t enough, automatically fall back to using native TON. (github.com)

---

Building a marketplace on TON: patterns that work

A lean, tough marketplace consists of an off-chain indexer, on-chain listing contracts, royalty compliance, and Jetton payments.

What to Reuse

Reusing items is a great way to save money, reduce waste, and get creative. Here’s a list of some common things you can easily reuse:

1. Glass Jars

These are super handy! Instead of tossing them out, repurpose those old glass jars for storage, DIY projects, or even as planters. You can even use them for homemade jams or candles.

2. Plastic Containers

Before you toss those takeout containers, consider cleaning them up. They make perfect food storage or organization bins in your kitchen or garage.

3. T-Shirts

Old T-shirts can be transformed into rags, tote bags, or even fun crafts. Just grab some scissors, and let your imagination run wild!

4. Egg Cartons

Egg cartons are not just for eggs! You can use them for organizing small items, starting seeds for gardening, or even as paint trays for kids' art projects.

5. Wine Bottles

Instead of recycling, give those wine bottles a new life! They can be used as vases, candle holders, or even DIY lamps.

6. Cardboard Boxes

Never underestimate the power of cardboard! They’re perfect for storage or crafting. You can make personalized organizers or even playhouses for the kiddos.

7. Old Towels

Those frayed towels can still be useful. Cut them up for cleaning rags or donate them to shelters. They’ll always come in handy!

8. Furniture

Before you decide to throw out that old chair or table, think about giving it a makeover. A little paint or some new upholstery can breathe new life into old furniture.

Conclusion

Reusing items not only helps the environment, but it can also spark your creativity. So next time you’re about to toss something out, take a moment to think about how you might breathe new life into it. Happy reusing!

• Check out Getgems’ open contracts--they show off some cool fixed-price and auction styles, complete with royalties. They even share code hashes for the sale versions they support, along with a handy example of a 5% marketplace fee. This is pretty helpful if you’re testing for compatibility! (github.com)
• Getgems makes it super easy to list and buy NFTs using Jettons like USDT or NOT. This shows that Jetton-based sales are totally ready to go in production! (getgems.helpscoutdocs.com)

7Block Labs Marketplace Blueprint

Introduction

Welcome to the 7Block Labs Marketplace Blueprint! This guide lays out everything you need to know about creating an engaging and effective marketplace. Whether you’re a seasoned developer or just starting out, we’ve got you covered.

Key Components

Here's a breakdown of the essential components you should integrate into your marketplace:

1. User-Friendly Interface
   Make sure your marketplace is easy to navigate. A clean and intuitive design can make all the difference.
2. Robust Search Functionality
   Users should be able to find what they’re looking for without hassle. Implement filters and categories to enhance search capabilities.
3. Secure Payment System
   Security is crucial. Choose reliable payment gateways to ensure safe transactions for your users.
4. Vendor Dashboard
   Give vendors the tools they need to manage their products effectively. A solid dashboard can help them track sales, inventory, and customer interactions.
5. Review and Rating System
   Let users share their experiences! A review system builds trust and encourages quality.
6. Customer Support Options
   Make sure your users can get help when they need it. Consider live chat, email support, or a comprehensive FAQ section.

Development Process

Here's a step-by-step guide to help you kick off your marketplace development:

1. Research and Planning
   Understand your target audience and their needs. Draft a detailed plan that outlines your marketplace goals.
2. Choose Your Tech Stack
   Pick the right technologies that will support your marketplace. This could include frameworks, programming languages, and database systems.
3. Design the User Experience
   Focus on creating a seamless experience. Wireframes and mockups can be really helpful here!
4. Develop the Marketplace
   Put your plan into action! Start coding and building out your marketplace based on your designs.
5. Testing
   Test thoroughly to catch any bugs and ensure everything functions smoothly. User feedback during this phase is golden.
6. Launch and Marketing
   Once everything’s polished up, it’s time to launch! Use various marketing strategies to promote your marketplace and attract users.

Conclusion

Building a marketplace is no small feat, but with the right approach and the 7Block Labs Marketplace Blueprint, you’re well on your way to creating something amazing. Dive in, experiment, and don’t forget to have fun along the journey!

For more resources, check out our 7Block Labs website for tutorials and tips. Happy building!

• Per-listing sale contract: When a seller wants to sell an NFT, they transfer it to a sale contract. This contract acts like an escrow, taking care of the item while also enforcing the price, the currency (that’s the Jetton master address), royalties (TEP-66), and marketplace fees. This setup helps manage risk on a per-listing basis and naturally divides things up. (docs.ton.org)
• Jetton support: The system supports a whitelist of accepted Jettons (masters). It reads decimals straight from the metadata and needs the buyer’s Jetton wallet to send a comment or receipt to the sale contract for proper accounting. (docs.ton.org)
• Auction mode: The auction follows the established contract structure. It keeps bid increments and end-time logic stateless within the item’s sale contract. This approach helps to avoid any centralized coordination issues. (github.com)

Operational Reality

When we talk about operational reality, we’re diving into how things really work on the ground, not just what’s written in manuals or company policies. This is where theory meets practice.

Key Components

1. People: The individuals involved in operations often have unique insights that can make a huge difference. Their experiences shape how processes are implemented.
2. Processes: While we can have the best policies in place, it’s the actual processes that dictate how work gets done. Flexibility is key here, as things can change quickly.
3. Tools and Technology: The software and tools we use can either simplify or complicate our workflows. It’s important to choose wisely and ensure everyone is on board.
4. Environment: External factors, like market trends or regulatory changes, can impact operations significantly. Staying adaptable is crucial.

Challenges to Consider

• Communication Gaps: Miscommunication can lead to mistakes. Keeping everyone in the loop helps minimize errors.
• Resource Allocation: Sometimes, the right people or tools aren’t available when you need them. It’s a common hiccup that requires creative solutions.
• Resistance to Change: Not everyone is on board with new methods or technologies. It’s important to manage this resistance with training and support.

Conclusion

Understanding operational reality is vital for success. It’s about recognizing the difference between what’s supposed to happen and what actually unfolds. By focusing on the people, processes, tools, and environment, we can navigate the challenges and improve our operations over time.

• When you’re indexing with TonAPI’s Events/Jettons endpoints, just a heads up: don’t base your business logic on Events since they could change anytime. Instead, stick with traces and contract state. You can find more details here.
• If you’re dealing with USDT-priced listings, make sure to normalize amounts to 6 decimals. It’s also a good idea to use a decimals-aware component when building price inputs to avoid any admin slip-ups. Check out the guidelines here.

---

Fees, reserves, and storage: avoid “dead account” surprises

• The total fee is made up of storage, in_fwd, compute, action, and out_fwd. Think of storage as a continuous rent on bits or cells, and you can actually lower costs for shared structures by deduplicating identical cells. Check out more details here.
• Be sure to always reserve multi-year storage in every contract. When you’re figuring out your bounds, use the max cells or bits you've observed in your tests. Instead of hardcoding fee amounts, stick to maximum sizes, and remember to adjust based on whether you’re using the masterchain or basechain. You can find more info here.

Practical Defaults We Use

When it comes to using defaults in our projects, we often rely on a set of practical choices that help streamline our workflow and ensure consistency. Here’s a quick rundown of the defaults that we commonly stick to:

Default Settings

1. Language: We typically default to English for all our documentation and coding styles. It’s just easier that way since most of our team is comfortable with it.
2. Coding Standards: We follow Airbnb’s JavaScript Style Guide. It’s pretty comprehensive and helps keep our codebase clean and understandable.
3. Version Control: Git is our go-to for version control. We standardize on the main branch as our primary branch and encourage everyone to make feature branches from there.

Environment Configurations

• Development: We set up our local environments to mirror our production settings as closely as possible. This includes using Docker for containerization, making it easier to manage dependencies.
• Testing: By default, we use Jest for unit testing in JavaScript projects. It’s fast, easy to set up, and integrates nicely with our CI/CD pipelines.

Tools and Libraries

• Frameworks: React is our default choice for front-end development. It’s flexible, efficient, and has a strong community backing it up.
• Styling: For CSS, we lean towards styled-components. It keeps our styles scoped and makes it easier to manage styles within components.

Deployment

• Hosting: Our default hosting service is Vercel. It’s user-friendly and works well with our frontend stack, plus it offers automatic deployments.

Documentation

• Format: We prefer to write all our documentation in Markdown. It’s simple, easy to read, and works well with GitHub and other platforms.

By sticking to these defaults, we create a smoother experience across our projects, making sure everyone’s on the same page and reducing the chance of mix-ups. If you have thoughts or suggestions for adjustments, feel free to share!

• A storage budget that covers 5 to 10 years for every contract we deploy.
• Unit tests that push the limits with worst-case metadata in the state and check those reserve calculations. (docs.ton.org)

---

Message safety: bounce rules and send modes you must honor

• By default, internal messages should be bounceable. Make sure to set up onBounced handlers and avoid executing the original body from any bounced payloads. Only think about using "RichBounce" when you're after the full body and exit codes; in most cases, it's better to stick to the more economical 256-bit bounce data. (docs.ton.org)
• Get a good grip on the different send modes, including who’s covering the forward fees and how rollback behaves. It's super important to jot these down in your review checklist--messing up the modes can lead to silent burns or missed bounces. (docs.ton.org)

---

Security hardening: TON‑specific traps and patterns

• Make sure to have replay protection for external entries and reject any stale sequence numbers.
• Always verify external messages before accepting them; only spend gas_credit after running your checks.
• Pre-budget your gas and don't hesitate to reject messages with a value that's just too low early on.
• Keep admin upgradability clear; remember, TON allows for setcode--gate your updates and issue proofs.
• Avoid leaking any secrets on-chain; simulate to ensure everything is secure. (docs.ton.org)

Tact/Tolk Resources

• Tact has gone through a Trail of Bits audit and is building a solid ecosystem, so definitely check out its security guide. Tolk is set to be the official language moving forward, and both of these work nicely with Blueprint. You can find more details here: (docs.ton.org).

---

Tooling that speeds teams up (and reduces regressions)

• Blueprint: Kick things off by scaffolding, compiling (using Tolk/FunC/Tact), running tests with @ton/sandbox, and deploying through TON Connect. Just start with npm create ton@latest, then follow it up with blueprint build/test/run. Check out the details here.
• Sandbox: Use the sandbox network for integration tests that interact with realistic APIs. More info can be found here.
• TonAPI: This is your go-to for balances, holders, actions, and emulation. You can even embed their Events, though remember to include that “UI only” warning! Get the scoop here.
• Assets SDK and Wallet V5: These wrappers let you handle transfers and sales in a snap. For more details, head over here.

---

Example: a Jetton + marketplace MVP that ships in 6-8 weeks

Week 1-2: Token Spec + Governance

• Go with Jetton 2.0, set those decimals, figure out mint caps, and decide on admin powers; get the semi-chain metadata ready.
• Nail down which currencies to accept for the marketplace (like USDT and TON). Check out the details here.

Week 2-3: Contracts

• Get that Jetton master/wallet up and running with shard-aware placement.
• Fork those sale contracts (starting with fixed-price) to include a Jetton whitelist, TEP-66 royalties, and a marketplace fee. Check it out here: (beta-docs.ton.org)

Week 3-4: Client + Wallet

• Get TON Connect up and running; make sure to include decimals-safe inputs; and roll out the Wallet V5 gasless option for USDT. (github.com)

Week 4-5: Indexer + Ops

• Start indexing with TonAPI, set up trace-based settlement checks, and create alerts for bounces or low reserves. Check out the details here.

Week 5-6: Security + Test

• Run unit tests in the Sandbox, check storage reserves, test bounced messages, and ensure send-mode coverage.
• Get a third-party review and turn on those static analyzers (Misti, TSA). Check out the details here.

Optional: Check out the mintless airdrop module for growth, or you could go for the auction flow using Getgems' patterns. You can find all the details here: github.com

---

7Block Labs delivery approach

• Focus on the product first: let's dive into tokenomics and user experience reviews before we get into the code.
• Shard-aware design reviews are a must for the critical paths like buys, bids, and claims.
• Think of it as a security gate: we're talking replay protection, handling bounced paths, keeping storage reserves, upgrade keys, and making sure those decimal checks are on point.
• We need good observability: that means traces-based settlement, balance reconciliators, and fail-safes for those gasless relay sends.
• And let’s not forget about documentation: we should have a solid manifest for TON Connect, clear decimals policy, a list of accepted Jettons, different send modes, and emergency runbooks ready to go.

If you’re diving into TON for consumer-level apps or integrating Telegram flows, we can get you from brainstorming to a fully audited mainnet in just a few weeks--not months.

---

Reference links used in this guide

• Check out the Jettons overview (TEP‑74) and how the distributed architecture works. There's also a comparison of Jetton and Jetton 2.0. (docs.ton.org)
• Dive into token metadata (TEP‑64) featuring decimals and Snake encoding. (docs.ton.org)
• Learn about transfer mechanics like forward_payload, forward_ton_amount, and the risks with decimals. Plus, there's a handy code wrapper example. (docs.ton.org)
• Check out the Mintless Jetton (TEP‑177/176) reference implementation. (github.com)
• Explore Wallet V5, which includes features like gasless transactions, multi-send, and the API. Don’t forget to look at the repo! (docs.ton.org)
• Get an overview of TON Connect and all its SDKs. (docs.ton.org)
• Curious about sharding? Discover the latency of cross-shard hops and how to deploy “close to” another contract. (docs.ton.org)
• Need to understand fees? Here’s a breakdown, along with the storage fee formula and deduplication info; plus, check out some reserve patterns. (beta-docs.ton.org)
• Learn about marketplace contracts and Jetton sales through Getgems, along with royalty references (TEP‑66 via NFT reference). (github.com)
• If you're looking to airdrop via Ton Console, remember to use CSV format and set decimals=6 for USDT. (docs.tonapi.io)
• Brush up on security best practices for TON and Tact. (docs.ton.org)
• Explore the Tact language and its adoption, audit processes, along with the Blueprint and Sandbox tooling. (docs.ton.org)

---

Brief in‑depth details (TL;DR for engineers)

• Always grab the decimals from the metadata before crunching any numbers; make sure to cache it per Jetton master with a time-to-live. (docs.ton.org)
• When dealing with USDT pricing, keep it normalized to 10^6 across the board (UI, server, contracts); don’t forget to add unit tests that will fail if a token’s decimals don't match what we expect. (docs.ton.org)
• Use Wallet V5's internal_signed feature along with relay for gasless transactions; be sure to guard against seqno races and handle any conflicting signatures on the server side. (docs.ton.org)
• Set the toShard for sale contracts to be close to the buyer/seller wallets, especially when they’re receiving funds often. Start off with fixedPrefixLength=8 and measure the hops in the staging environment. (beta-docs.ton.org)
• It’s smart to reserve 5-10 years of storage based on the measured max bits/cells; make sure to assert these reserves in your tests. (docs.ton.org)
• Go with bounceable internal messages by default; set up onBounced with inexpensive 256-bit bodies; only switch to rich bounce when exit codes are actually needed. (docs.ton.org)

7Block Labs can handle everything from implementing to auditing and operating your entire token and marketplace stack.