TON Guide

As the TON and Telegram networks continue to expand, now boasting over 38 million active accounts, the growing user base unfortunately also attracts scammers and malicious actors. These individuals are targeting the influx of new and less experienced users, seeking to exploit the accessibility that TON and Telegram have brought to the crypto world. While the opportunities in cryptocurrency are promising, it’s crucial to be aware of potential dangers, even within well-regulated environments. In this guide, we’ll outline common scams and offer tips for protecting yourself.

By staying informed, you can fully enjoy the benefits of TON and Telegram while minimizing risk.

Common Scams to Avoid

Impersonation Scams: Fraudsters may pose as friends or family, urgently requesting money. Always verify their identity before responding.

Phishing Schemes: Fraudulent websites may mimic legitimate ones to steal login credentials. Double-check URLs and avoid clicking on unsolicited links.

Investment Fraud: Promises of high returns with no evidence are common in crypto scams. Conduct thorough research—if it seems too good to be true, it likely is.

Survey Scams: Offers claiming prizes for survey participation may be attempts to gather personal information. Avoid sharing your details with unfamiliar survey requests.

Job Offer Scams: Be cautious of enticing job advertisements that request personal information or payments. Verify these offers through official channels.

Classified Ad Scams: Fake ads may direct you to deceptive Telegram bots designed to collect personal information.

Pump and Dump Schemes: Some groups artificially inflate crypto prices to profit, leaving others with losses. Always research and verify investment recommendations.

Romance Scams: Scammers in online relationships may request money or personal details. Exercise caution with online acquaintances asking for financial assistance.

Be Aware of Toncoin Pyramid Schemes

The support Telegram provides for the TON Blockchain has unfortunately attracted scammers seeking to exploit naive users. Here’s a detailed look at a typical scam:

Initial Setup: Scammers distribute links to “exclusive earning programs” that appear to come from trusted contacts. They direct users to join an unofficial Telegram bot, falsely claiming it’s for secure cryptocurrency storage.

Investment Phase: Users are encouraged to buy Toncoin through legitimate channels like Wallet, P2P markets, or exchanges, lending the scam false credibility. Once acquired, users are instructed to transfer their Toncoin to the scam bot.

Booster Purchases: Victims are urged to buy “boosters” through a separate bot, costing between 5 to 500 Toncoin. At this stage, users lose their cryptocurrency.

Recruitment Efforts: Scammers promote a referral scheme, asking users to set up private Telegram groups and recruit friends. They promise earnings from a fixed payment of 25 TON per referral and commissions based on the boosters purchased by referrals.

In reality, this is a classic pyramid scheme where the scammers profit at the expense of others.

Tips for Staying Safe

To protect yourself from online fraud and ensure the security of your Telegram account, follow these essential practices:

Enable Two-Step Verification: Go to Settings > Privacy and Security > Two-Step Verification to add an extra layer of security to your Telegram account.

Verify Contacts: Be cautious of unsolicited requests for personal information or money. Confirm the identity of the sender through alternate means.

Regularly Review Account Activity: Check Settings > Devices > Active Sessions to identify any unknown devices or sessions accessing your account.

Report Suspicious Activity: If you encounter a scam, report it to Telegram immediately.

Avoid Get-Rich-Quick Schemes: Exercise caution with schemes, even if recommended by acquaintances—they may unknowingly be victims themselves.

Verify Cryptocurrency Transfers: Always ensure you are sending cryptocurrency to a verified recipient to avoid scams.

Staying secure on TON and Telegram requires vigilance and awareness. By recognizing common scams and adhering to these safety tips, you can safeguard your assets and personal information. Always verify sources, be wary of overly promising offers, and use only official channels for transactions. By staying informed and cautious, you can enjoy the advantages of TON and Telegram without falling prey to fraud.

Decentralized technology is paving the way for the future, fostering genuine democratization and fairness. The world is increasingly turning towards blockchain and its diverse applications. Among these, The Open Network (TON) stands out as a high-speed, cost-effective, and eco-friendly layer-1 blockchain, crafted to accommodate billions of users.

Harnessing Python with TON

TON offers a decentralized layer-1 blockchain renowned for its rapid and efficient transactions. Despite its advantages, the FunC and Fift programming languages associated with TON can be quite challenging for developers to master. Enter Rift.

Rift enables developers to harness the power and flexibility of Python to create and interact with TON. With Python’s intuitive syntax and object-oriented programming (OOP) capabilities, developers can easily write and test smart contracts without the need to acquire a new programming language.

Rift serves as the gateway connecting Python with the world of TON.

Streamlining Development with Rift

Rift provides a comprehensive set of tools for developing on TON. It simplifies the entire development workflow, from crafting smart contracts in Python to testing and deploying them on the TON network. With Rift’s all-in-one framework, developers only need to be familiar with Python 3.10 to start creating on TON.

Here are a few of the standout features that make Rift an essential resource for TON development:

Enhance Your Smart Contract Creation with Rift

Rift allows developers to leverage Python’s syntax and features to effortlessly build smart contracts for TON. There’s no need to master a new programming language or deal with compatibility challenges—Rift integrates the strengths of Python with TON, making blockchain development more accessible and efficient.

Class Definition

class SimpleWallet(Contract):

Data Model

The SimpleWallet class includes an inner class called Data, which is a model representing the contract’s state. It has two attributes:

• seq_no: A 32-bit unsigned integer that tracks the sequence number of transactions.
• public_key: A 256-bit unsigned integer that stores the public key used for verifying signatures.

class Data(Model):

External Body

The ExternalBody class represents the structure of external messages received by the contract. It includes:

• seq_no: A 32-bit unsigned integer matching the sequence number in the contract’s state.
• valid_until: A 32-bit unsigned integer indicating the expiration time of the message.

class ExternalBody(SignedPayload):

Contract Data

The SimpleWallet class maintains a single instance of Data to track the current state of the wallet.

External Message Handling

The external_receive method processes incoming messages. The method performs the following steps:

1. Parse the Message: It extracts the message body as an ExternalBody instance.
2. Verify Validity:
• Checks if the message’s valid_until timestamp is greater than the current time.
• Verifies that the seq_no in the message matches the current sequence number in the state.
• Validates the message’s signature using the stored public key.
3. Accept the Message: If all checks pass, the message is accepted.
4. Process References: It handles any references within the message, sending them as raw messages with the specified mode.
5. Update State: Increments the sequence number and saves the updated state.

This contract exemplifies a simple wallet system with basic functionality for managing and verifying transactions in a blockchain environment.

Mastering TON Interaction with Rift

Rift offers a comprehensive solution for working with TON, simplifying every aspect of network engagement. It consolidates all essential TON development tools into a single interface, making it incredibly straightforward for developers to:

• Create Messages: Easily construct and manage messages within the TON network.
• Sign Messages: Utilize the Fift backend to securely sign messages.
• Execute Contracts: Run and test contract codes efficiently.
• Deploy Contracts: Seamlessly deploy smart contracts to the network.
• Engage with the Network: Use the Tonlibjson backend for smooth network interactions.

With Rift, developers can streamline their workflow and fully harness the capabilities of the TON network.

Thoroughly Validate Your Contracts

Rift offers a comprehensive testing framework for the TON Virtual Machine (TVM), simplifying the process of validating contracts before their deployment on the main network. This framework delivers an intuitive interface for crafting message bodies and examining the contract’s state to verify its functionality.

In this code:

• test_transfer() initializes a JettonWallet instance and performs a token transfer. It then verifies that the transfer was successful.
• test_transfer_no_value() initializes a JettonWallet instance and attempts to send tokens with a zero value, checking that an error is returned.

Embrace the Future with TON

TON has the power to transform the blockchain landscape, and Rift is the ideal tool to harness its full potential. Whether you’re new to TON or a seasoned developer, Rift offers a streamlined approach to accelerate your development and realize your ideas on the TON network. Don’t miss out—start building with Rift today and become part of the TON transformation!

Begin Your Journey Today

Dive into Rift’s repository and join the Skyring Channel to stay up-to-date with the latest developments. We’re thrilled to announce that comprehensive guides will be available soon. Keep an eye out for more information!

TON is a state-of-the-art blockchain that brings some pretty cool new ideas to the table when it comes to smart contract development. TON was designed after Ethereum came out, so it benefits from insights into the EVM model’s strengths and limitations, allowing for significant improvements.

If you’ve worked with smart contracts before, you’ll probably know about Ethereum’s Solidity language and the EVM. As you start looking into TON development, it’s important to understand the different design choices that lead to different behaviours compared to what you might expect from Ethereum. This post aims to outline some of these key differences and provide insights into the rationale behind them.

Transitioning from Data to Big Data

The key to understanding TON is recognizing that it was engineered to bring blockchain technology to billions of people worldwide. This requires an immense scale, with the potential for billions of users conducting billions of transactions daily.

Consider this shift as moving from managing standard data to handling big data. For example, storing a restaurant’s menu in an SQL database is effective because it allows for powerful and flexible queries with all the data easily accessible. However, when it comes to storing every Facebook post made by billions of users globally, an SQL database is no longer a viable option. In this context of “big data,” aggressive sharding is necessary, which in turn limits the flexibility of the queries you can perform. It’s a matter of making different trade-offs to meet different objectives.

Here are six distinctive features of the TON blockchain that might surprise Solidity developers:

1. Smart Contracts Must Pay Rent and Charge Users

The idea of using blockchain as a permanent, unchangeable storage solution is appealing in theory but proves challenging when scaled. Ethereum’s fee model is akin to that of a bank: when you send money, you pay a transaction fee, and the user who initiates the transaction covers this cost. Similarly, when you deploy a new smart contract on Ethereum, the sender of the deployment transaction pays a one-time fee. However, since the data on the blockchain is intended to be permanent, miners bear the ongoing infrastructure costs to maintain it indefinitely. This economic model becomes unsustainable at scale, especially when considering billions of users.

• From a Bank Model to an Instant Messenger Approach

TON takes a different approach to fees, drawing inspiration from web apps like instant messengers rather than banks. For example, when you send a message on Facebook Messenger, you don’t directly pay a fee. Instead, the app developer (Facebook Inc., now Meta) covers the cost, and it’s up to them to recoup these expenses and sustain the platform.

Similarly, in TON, the dapp itself must cover its resource costs. Each smart contract holds a balance of TON tokens, which it uses to pay for rent. If the smart contract runs out of funds, it will eventually be removed from the blockchain (though recovery is possible). Unlike Ethereum, where storage fees are paid only once, TON’s model requires continuous rent payments. This means that the longer data is stored, the more it costs, aligning better with the ongoing expenses miners incur, and making it more scalable.

• Flexible Funding Options for Developers

Just as Facebook Inc. has various ways to fund its operations, developers on TON have significant flexibility in financing their smart contracts. They can choose to subsidize the contract out of their own TON tokens or charge users gas fees for specific actions, using those fees to cover future rent payments. This flexibility allows developers to tailor their economic models according to their dapp’s needs and ensures a more sustainable operation over time.

1. Smart Contract Interactions in TON Are Asynchronous and Non-Atomic

One of Ethereum’s greatest strengths in fostering a robust DeFi ecosystem is the smooth composability of smart contracts. Within a single transaction, you can perform complex operations such as using WBTC as collateral in a Compound contract, borrowing USDC, trading it on Uniswap for more WBTC, and leveraging your position—all in one go. This entire process is atomic, meaning that if any step fails, the entire transaction is rolled back as if it never occurred.

In Ethereum, when a smart contract calls a function on another smart contract, the call is executed immediately within the same transaction. This synchronous execution is akin to running your entire backend on a single server, where every component can directly and instantly interact with every other component. This approach is straightforward to manage and reason about but has a significant limitation: scalability. The system can only expand as long as everything remains within that single environment.

In contrast, TON handles smart contract interactions differently. Calls between smart contracts are asynchronous and non-atomic, meaning that when one contract calls another, the call doesn’t happen immediately within the same transaction. Instead, the process is broken up, and each step occurs independently. If something goes wrong in one step, the other steps don’t automatically roll back. This design is more scalable but requires developers to approach contract interactions with a different mindset, considering the potential delays and non-reversibility in the process.

Transitioning from a Single Server to a Microservices Cluster

If you think of Ethereum as a monolithic system running on a single server, TON is more akin to a cluster of microservices. In this setup, each smart contract might be running on a different machine. When two smart contracts need to communicate, they do so by sending messages across the network, much like microservices in a distributed system. Because these messages take time to travel, communication between contracts becomes asynchronous. This means that when your smart contract calls a method on another contract, the call is processed after the transaction is complete, in a subsequent block.

This asynchronous model introduces complexities that are not present in Ethereum’s synchronous environment. For instance, what if the conditions change between the time a message is sent and when it is received? Imagine a scenario where the balance of the calling contract has altered by the time the second contract processes the call. Ensuring consistency becomes more challenging, and the likelihood of bugs increases. Additionally, atomicity—where a series of operations either all succeed or all fail—no longer happens automatically. If you chain multiple calls and the last one fails, you’ll need to manually roll back the previous changes, adding another layer of complexity to smart contract development on TON.

1. Your Smart Contract Can’t Directly Query Other Contracts

This limitation is a direct consequence of the asynchronous nature of contract interactions in TON. In Ethereum, where contract calls are synchronous, reading data from another smart contract is straightforward. For example, if your contract needs to know its balance of USDC, it simply calls the getBalance method on the USDC contract.

Returning to the analogy of a monolithic system running on a single server, one of the advantages is that every service can instantly access the state of any other service. This makes querying data between contracts in Ethereum easy and efficient. However, in TON, where contracts operate more like separate microservices, this direct access isn’t possible. Instead, retrieving data from another contract requires sending a message and waiting for a response, which complicates the process and introduces delays.

Shifting from a Single Server to a Microservices Cluster

In a system where separate microservices run on different machines, direct access to state memory across services becomes impossible. On TON, smart contracts can only interact by sending asynchronous messages. If your contract needs to query data from another contract and requires an immediate response, you’re out of luck.

The situation gets even more peculiar. If you come across getter methods on a TON smart contract, such as getBalance, these methods aren’t accessible from other smart contracts. Instead, getter methods are designed to be called only by off-chain clients, much like how an Ethereum wallet might use a service like Infura to query the state of any smart contract.

1. Smart Contract Code on TON Is Not Immutable and Can Be Easily Modified

The concept of dapps on Ethereum draws inspiration from legal contracts, where the terms are set in stone once agreed upon—hence the term “smart contracts.” In this analogy, the developer writes the terms of the contract as code, and that code becomes the unchangeable law. In the real world, when two parties sign a contract, the agreement is fixed, and any changes require drafting a new contract.

Following this philosophy, Ethereum’s smart contract code was designed to be immutable, meaning it cannot be altered once deployed. However, over time, developers have found ways to work around this limitation by employing complex patterns, such as using proxy contracts that delegate calls to another contract, thereby allowing for upgrades without changing the original contract’s code.

In contrast, TON takes a different approach. The code of smart contracts on TON is not inherently immutable and can be modified more easily. This flexibility allows developers to update and improve their contracts without resorting to convoluted workarounds, making the process of upgrading smart contracts more straightforward on the TON blockchain.

Shifting from Legal Contracts to Software Engineering

Unlike lawyers, who assume that contracts are set in stone, software engineers understand that every piece of code is prone to bugs, and even if the code were flawless, requirements often evolve, necessitating updates and modifications.

In TON, the notion that smart contracts must be immutable is entirely abandoned. Smart contracts on TON can freely modify their own code, just as they would any other state variable. If a contract writes to its code variable, it becomes mutable; if it doesn’t, it remains immutable. This approach simplifies the process, eliminating the need for complex proxy patterns and making it easier to update and maintain smart contracts.

1. Avoid Unbounded Data Structures in Your Contract State

This concept can be challenging to grasp at first, but it’s essential for understanding why certain smart contracts on TON are designed in specific ways.

Unbounded data structures in smart contracts are state variables that can grow without limit. Take, for example, an ERC20 contract like the one implementing the USDC token. This contract needs to maintain a mapping of user addresses to their respective balances. Since USDC can be minted in large quantities and divided into small fractions, the number of holders—and thus the number of entries in this map—can increase indefinitely.

Now, consider what happens if an attacker tries to overwhelm the contract by continuously adding new entries. Could this lead to a denial-of-service (DoS) attack, preventing legitimate users from interacting with the contract? On Ethereum, this issue is addressed effectively. The fee model requires users who write new data to the contract state to pay a fee for that data. This means that any attacker attempting to spam the contract would incur significant costs. Additionally, the gas cost for writing to a map on Ethereum is fixed, regardless of the map’s size, ensuring that legitimate users are not penalized by the spam.

In summary, Ethereum’s fee structure makes spamming with unbounded data structures economically unfeasible, and the system itself provides a layer of protection.

Transitioning from Unbounded Maps to Unbounded Contracts

For TON smart contract developers, the system doesn’t automatically protect against spamming unbounded data structures within a contract’s state. Unlike Ethereum, where gas fees for writes are constant, TON’s gas fee model makes write costs proportional to the amount of data in the structure. This is due to TON’s “Bag of Cells” architecture, where the contract state is divided into 1023-bit chunks known as “cells,” which the developer must manage. In this setup, maps are implemented as a tree of cells, and writing to a leaf node requires updating hashes along the entire tree. If an attacker spams the map with keys, they could push some user balances deep enough into the tree that updating them exceeds the gas limit.

To mitigate this risk, the best practice in TON is to avoid unbounded data structures in your contract state. This helps protect your contract from potential DoS attacks. The solution typically involves contract sharding: instead of storing an infinite number of user balances in a single USDC contract, you can split the contract into multiple child contracts, each managing the balance of a single user.

This approach explains why, on TON, NFT collection contracts place each item in a separate contract (since the number of items can be unlimited), and why fungible token contracts create individual contracts for each user’s balance.

To understand why TON is designed this way, it’s important to consider the limitations of Ethereum’s gas fee model, where the cost of writing to a map is fixed regardless of the map’s size. While this simplicity works for small maps, as maps grow to billions of entries, the effort required by miners to update them increases significantly, making a more scalable solution like TON’s necessary.

1. Wallets Are Smart Contracts, and One Public Key Can Deploy Multiple Wallets

On Ethereum, a user’s wallet is directly tied to their address, which is derived from a public key and its corresponding private key. This creates a one-to-one relationship: one address per public key and one public key per address. As long as the user has access to their private key, they retain control over their wallet.

Moreover, on Ethereum, users don’t need to take any special actions to have a wallet—it’s simply their Ethereum address. This address can store ETH, hold ERC20 tokens and NFTs, and directly interact with other smart contracts by sending and signing transactions.

In contrast, on TON, wallets are actually smart contracts themselves. This means that a single public key can be associated with multiple wallets, each potentially offering different functionalities. As a result, users can deploy several wallets from the same public key, each tailored for specific purposes, providing a level of flexibility and customization not seen in Ethereum’s more straightforward model.

Shifting from Address to Smart Contract

In TON, wallets aren’t automatically provided; they are independent smart contracts that must be deployed just like any other contract. When a new user begins using the TON blockchain, their first task is to deploy a wallet on-chain. The wallet’s address is generated from the wallet contract’s code and various initialization parameters, such as the user’s public key.

This setup allows users to deploy multiple wallets, each with a unique address. These wallets can vary in their underlying code (as new versions are periodically released by the foundation) or in their initialization parameters (one common parameter is a sequence number). As a result, even if a user retains their private key, they still need to remember their wallet address or the specific initialization parameters used during its creation.

When sending a transaction to a dapp on TON, the process differs from Ethereum. The user signs a message with their private key, but instead of sending this transaction directly to the dapp’s smart contract, it is sent to the user’s wallet contract. The wallet contract then forwards the message to the dapp’s smart contract.

This design provides TON with a greater degree of flexibility. The community can develop new types of wallet contracts over time. For example, a wallet without a nonce (transaction sequence number) could be created, allowing multiple transactions to be sent in parallel from different clients without prior synchronization. Additionally, specialized wallets like multi-signature wallets—which on Ethereum require a separate smart contract—can function seamlessly alongside regular wallets on TON.

Hello, reader! This series of posts will serve as your guide to mastering FunC development.

Introduction to FunC Development: A Step-by-Step Guide

To help you navigate this journey effectively, I’ll provide you with a roadmap and practical tips, guiding you through the lessons so you can gain a solid understanding of FunC and potentially create your own applications on the TON blockchain.

Embarking on the TON Ecosystem

As we set our sights on the TON ecosystem, our journey begins…

Smart Contracts on the TON Blockchain

The TON network is powered by TVMs (TON Virtual Machines), where smart contracts—programs stored on the blockchain—execute when specific conditions are met. The high-level language FunC is used to develop these smart contracts on the TON blockchain. FunC code is compiled into Fift assembler code, which in turn generates the bytecode that runs on the TVM.

Any developer can create a smart contract and deploy it to the TON network by paying a network fee. Users can then interact with the smart contract by executing its code, again for a fee paid to the network.

Through smart contracts, developers have the ability to create and deploy complex user applications and services.

It’s also worth noting that once published, smart contracts are assigned a unique address on the network.

As we venture into the TON ecosystem, the first thing we encounter is a “forest” of cells. To make sense of this and move forward, we need to understand data types, exceptions, and functions in FunC.

Understanding Data Types, Functions, and Exceptions in TON

In the TON Blockchain, all persistent data is stored within trees of cells. Each cell can contain up to 1023 bits of arbitrary data and can reference up to 4 other cells. These cells serve as the memory for the stack-based TON Virtual Machine (TVM).

A FunC program is essentially a collection of function declarations/definitions and global variable declarations. Each function declaration or definition follows a common pattern:

Here, [ … ] denotes an optional component.

Special Functions in TON Smart Contracts

Smart contracts on the TON network have two key reserved methods that can be accessed:

• recv_internal(): This method is triggered when an action occurs within the TON network itself, such as when another contract interacts with yours.
• recv_external(): This method is executed when a request is made to the contract from an external source, outside of the TON network.

Handling Exceptions in Smart Contracts

An essential aspect of any smart contract is the ability to handle errors through exceptions. Exceptions can be triggered by using conditional primitives such as throw_if and throw_unless, or by the unconditional throw primitive.

To help you grasp these concepts, I’ve prepared a lesson where you’ll write your first smart contract and apply the information you’ve just learned in practice. [Link to the first lesson].

Congratulations! You’ve navigated through the “forest” of cells. However, to ensure others can follow the path you’ve created, we’ll need to test it.

Testing a Smart Contract

As you ponder the importance of testing, a wise figure approaches and informs you that there are currently two types of tests in TON.

V1 Tests

In the older V1 testing framework, each test requires the creation of two functions:

1. Data Function (or more accurately, a state function)
2. Test Function

For each test, you first establish the data or state using the data function. Then, within the test function, you outline the test logic, triggering exceptions whenever the logic is violated.

Although this is the older testing method, the sage encourages you to explore it to gain a deeper understanding of how testing works in TON. You can learn how to test the smart contract you created in the first lesson using V1 tests by following the instructions in the second lesson.

V2 Tests

As the sage departs, he gestures toward the horizon and mentions that TON now has a new testing framework that you should explore if you want to create tests more efficiently.

V2 Testing Framework

In the updated V2 tests, testing is streamlined through two key functions that allow you to invoke smart contract methods:

• invoke_method: Assumes that no exception will be thrown.
• invoke_method_expect_fail: Assumes that an exception will be thrown.

These functions are called within your test functions, which can return multiple values—all of which will be displayed in the test report when the tests are executed.

To distinguish test functions from helper functions, ensure that the name of each test function begins with __test. This naming convention helps identify which functions are tests and which serve as utilities.

Understanding the Stack and Registers in TON

As you delve deeper into the TON ecosystem, it becomes clear that mastering the concepts of registers and the stack is essential. Without this understanding, creating anything meaningful within TON is nearly impossible, making this knowledge a crucial part of your journey through the network.

Stack and Registers in TON

The TON Virtual Machine (TVM) operates as a stack machine, where the last element added to the stack is the first to be removed—following the Last In, First Out (LIFO) principle. As a result, when working with smart contracts, you often need to access data sequentially, even if some of it is not immediately relevant. For example, in the function below, we aim to retrieve the address, but must first read the flags, even though they are not used:

Additionally, the TVM’s state is managed by control registers, with c4 being the most commonly used register in TON smart contracts. The c4 register holds the root of the persistent data, essentially representing the contract’s data section, and this value is stored in a Cell.

As your journey through the TON ecosystem continues, you may establish several “smart contract base camps.” But the question remains: how do you effectively organize communication between them?

Sending Messages in TON

TON employs an actor model for communication between smart contracts. Each smart contract can receive a single message, modify its state, and send one or more messages within a given time frame. This model allows both the entire blockchain and individual contracts to scale, accommodating an unlimited number of users and transactions.

In addition, the TON blockchain and its hosted contracts can receive external messages from other blockchains or the broader web. This capability means that you can send a message to a TON smart contract without needing an on-chain account, enabling smart contracts to process and integrate external data for on-chain operations.

Testing Messages

As we venture further into the ecosystem, we encounter enigmatic stones inscribed with ancient runes….

To test smart contracts that interact with messages, we must first generate the necessary addresses. In TON, objects are described by TL-B schemes, so to determine what a test address should look like, we need to examine the block scheme.

It becomes apparent that the runes on these stones hold valuable information that will guide us on our journey.

To gain a deeper understanding of TL-B, I recommend studying the following resource: TL Language.

The Road Ahead

In this article, we embarked on our journey through the TON ecosystem, starting with the FunC programming language. I hope these initial steps have ignited your enthusiasm to continue exploring and learning more.

Hello, reader! This is the second installment of our exploration through the TON ecosystem. In this segment, we will delve further into various facets of FunC.

Current Overview

In the previous section, we introduced smart contracts on the TON network. We explored the purpose of messages, the role of the c4 register, and discussed testing methods. Now, let’s focus on elements that will enable you to build more sophisticated smart contracts.

Operations and Fees

As we advance in our exploration of the TON ecosystem, we’ll uncover important guidelines for smart contract interactions. Smart contracts within TON communicate with each other by sending internal messages. To streamline these interactions, certain recommendations have been established. A crucial aspect of these recommendations is the inclusion of query_id and op at the start of each message:

• op: Specifies the operation to be performed or the method to be invoked within the smart contract.
• query_id: Used in query-response messages to indicate that a response pertains to a specific query (when sending a reply).

Here’s an example of how it appears:

The more you delve into the TON ecosystem, the more you discover about interacting with its environment. Your team’s account manager suggests he has insights into making your smart contracts more efficient.

The TON network operates using its own cryptocurrency, Toncoin. This digital currency underpins a marketplace for computational resources. Such a marketplace creates economic incentives for participants to validate transactions, fulfill requests, and contribute computing power to the network. Every participant initiating a transaction request must pay fees in Toncoin. Since smart contracts also utilize Toncoin, optimizing them to minimize fees becomes crucial.

In the TON network, transaction fees are composed of several components:

1. Storage Fees: Charges for reserving space on the blockchain.
2. Inbound Forwarding Fees: Costs associated with processing external messages that are imported into the system.
3. Computation Fees: Fees for executing instructions within the TON Virtual Machine (TVM).
4. Action Fees: Charges related to handling a list of actions, such as sending messages.
5. Outbound Forwarding Fees: Costs for managing outgoing messages.

A straightforward method to lower fees is to employ the inline keyword for functions that are called infrequently, such as once or twice. This approach ensures that, during compilation, these functions are directly inserted at the call site.

The following is an example of how data loading can be handled when it is only required on a one-off basis.

Understanding Operations (Op)

Testing Operations

As a long-standing member of the TON ecosystem, you are aware that comprehensive testing is essential for all operations.

Testing Operations (Op) with Register c5

To evaluate how operations are executed, we need to determine what actions the smart contract has performed. For this, we utilize register c5.

Register c5 holds the output actions and is represented as a Cell. This register stores outgoing messages from smart contracts. During testing, we will send messages between addresses and examine the c5 register to ensure that all actions are correctly executed.

Please find below an example of the process for extracting a single message from register C5.

In this function:

1. Parse Actions List: The function begins by parsing the actions cell into a slice object.
2. Validate Structure: It checks the expected number of references and validates the presence of required fields.
3. Extract Data: The function extracts and validates the action_type, msg_mode, and msg from the parsed data.
4. Return Results: Finally, it returns the message mode and the message itself.

Lesson on Testing Operations

HashMaps

As smart contracts become more intricate, managing data efficiently, especially with respect to time, becomes crucial. This is where hashmaps, also known as dictionaries, come into play.

A hashmap is a data structure typically organized as a tree. It associates keys with values of any type, allowing for fast retrieval and modification. In FunC, hashmaps are implemented as cells.

The FunC standard library offers various functions to work with hashmaps efficiently. For instance, to add data to a hashmap, you can use the dict_set function. This function sets the value linked with a specific key index (of n-bit depth) in the dictionary to a slice and returns the updated dictionary.

Here’s an example of using dict_set:

Working with Hashmaps and Loops

To effectively manage hashmaps, loops are essential tools:

Loops are commonly employed when dealing with hashmaps. FunC provides three types of loops: repeat, until, and while.

Among these, the until loop is particularly useful for hashmaps. This is because many hashmap functions return a flag that makes it easy to determine when to end the loop.

Introduction to Hashmaps

Testing Hashmaps

When testing contracts that involve time-based logic, it’s crucial to utilize the c7 register. For effective testing, we need to create a helper function to manage time within the smart contract.

The c7 register holds the root of temporary data and is represented as a Tuple.

The helper function will enable us to set any required time value into this register. Here’s an example of how the helper function might be structured:

Since the smart contract includes both value storage and retrieval logic, it’s necessary to test the data from prior tests. This isn’t supported directly by the standard FunC library, but toncli provides a solution: In the toncli test descriptions, the get_prev_c4 and get_prev_c5 functions are available to retrieve the c4 and c5 cells from earlier tests.

To simplify working with tuples from the stack, the standard library includes the following functions:

• first — Retrieves the first element of a tuple.
• second — Retrieves the second element of a tuple.

Lesson on Testing Hashmaps

Next Steps

Congratulations on making substantial progress in your journey. In the upcoming section, we will explore token standards and NFTs within the TON ecosystem.

In this third installment of our FunC exploration, we’ll delve into the concept of tokens, the necessity of standards, and the specific token standards in TON. We’ll examine how the Jetton standard and the NFT collection standard function at a high level, and highlight some nuanced aspects of their implementation.

As our journey progresses, you come across a monumental edifice, a repository of wisdom… Anticipating your inquiries, the keeper of this repository directs you to the Tokens section.

Understanding Tokens

Cryptocurrency tokens represent units of digital value within a given network. It’s crucial to understand that tokens are not necessarily cryptocurrencies but rather entries recorded on the blockchain, managed through smart contracts. These smart contracts track account balances and enable token transfers between accounts.

While it may seem straightforward to create a smart contract that handles balance storage and token transfers, the challenge arises when every developer designs their own system from scratch. This would complicate integration for applications such as wallets, games, and analytics platforms.

To address this, blockchain networks have established standards developed collaboratively with the community.

The prospect of creating your own tokens for future use in the TON ecosystem prompts you to consult the guardian once more. You inquire: Where can I find the relevant standards?

TEP and Standards

Blockchains typically feature dedicated pages on GitHub or similar platforms where you can propose new standards or modifications. For TON, this is managed through a specific GitHub repository.

It’s crucial to remember that these repositories are not forums for open discussion but rather formal places for submitting and reviewing proposals. Ensure your contributions are well-considered and relevant to the repository’s purpose.

The first standard we’ll examine is the token metadata standard. This standard is essential for applications such as wallets and marketplaces, as it streamlines the process of retrieving and displaying token information. By standardizing how token data is represented, this standard facilitates a consistent user experience across different platforms.

Understanding Tokens in TON

Since tokens are implemented as smart contracts, they can potentially contain errors or vulnerabilities. It is important to thoroughly examine smart contracts before utilizing them.

After exploring Web3 for some time, you may have encountered tokens in various other ecosystems, but TON has distinct differences…

Differences in TON Tokens

The architecture of token smart contracts in TON diverges significantly from that of other networks. Unlike other systems, TON operates asynchronously, follows the actor model for interactions, and uses sharding for scaling.

A major distinction from other networks’ standards is the absence of a single smart contract that handles all functions. For instance, when deploying an NFT collection (which we will explore in more detail later), each item in the collection is managed by a separate smart contract, with an additional contract governing the entire collection.

For example, if you deploy a collection of 10,000 items, you will end up with 10,001 individual smart contracts.

You might wonder why this approach was adopted. In summary:

• Predictable Gas Consumption: This design allows for more predictable gas usage.
• Scalability Considerations: This approach does not inherently scale.

For a comprehensive explanation, refer to the NFT standard documentation.

Types of Tokens

Tokens can be categorized based on their fungibility, which is one way to classify them.

Fungible Tokens are assets that are interchangeable and identical in value. Each token within this category is equivalent to every other token of the same type, making them easily exchangeable. In TON, the standard for fungible tokens is the Jetton.

Non-Fungible Tokens represent assets that are unique and cannot be substituted with another asset. Each non-fungible token is a distinct digital certificate with a mechanism for transferring its ownership. In TON, the standard for non-fungible tokens is the NFT Standard.

Jetton

The standard for fungible tokens is known as Jetton. According to this standard, a Jetton token requires the deployment of two distinct types of smart contracts:

1. Master Contract: This primary smart contract is responsible for minting new Jettons, tracking the overall supply, and providing general information about the token.
2. Contract Wallets: These smart contracts handle the balance of each user’s Jettons.

For instance, if you issue a Jetton with a total supply of 200 tokens distributed among 3 users, you would need to deploy 4 contracts: one master contract and three contract wallets.

To help you grasp the standard and its implementation, I’ve prepared a lesson that covers both the theoretical aspects of the standard and practical examples of implementing the master contract and Jetton wallets.

NFT Standard

NFTs (Non-Fungible Tokens) in TON follow their own specific standard. Unlike fungible tokens, where the Jetton standard applies, NFTs are structured differently: each NFT item and NFT collection is managed through separate smart contracts.

NFTs offer an excellent way to document your FunC journey, but there are a few critical questions to address:

1. How to obtain a complete link to the content when there’s no unified list within the smart contract?
2. How to determine the address of the NFT or Token smart contract and what kind of StateInit allows for this?

Understanding StateInit

To deploy a smart contract on the network, the code and data for the contract are compiled into a StateInit structure. The address of the new smart contract is derived from the hash of this StateInit structure. An external message is then generated with a destination address matching the new smart contract’s address. This message includes the appropriate StateInit data and a non-trivial payload (signed with the correct private key).

In practical terms, this process means we can derive the address of a token’s smart contract by looking at the address where the tokens need to be sent. Essentially, by using the address and wallet code, we can reconstruct the StateInit of the wallet and retrieve the necessary address for the token wallet.

This approach is feasible because hashing functions are deterministic: they produce a unique hash for different inputs, and the same input will consistently yield the same hash.

NFT Item Content

Imagine you need to retrieve the address of a collection item, such as a link to an image. The process might seem straightforward: you use a Get-method to fetch the information. However, according to the NFT standard in TON, this approach will only yield a partial link, known as the individual item content.

To obtain the complete content, follow these steps:

1. Use the get_nft_data() method of the item to retrieve the element index, individual content, and the initialization indicator.
2. Verify if the item is initialized (details on this can be found in Lesson 10, which covers the NFT standard).
3. If the item is initialized, use the get_nft_content(int index, cell individual_content) method of the collection to obtain the full content (complete address) for the specific item.

To clarify the standard further, I have prepared a lesson on this topic.

Conclusion

This series marks the end of our journey through FunC. I will continue to share new lessons on my channel, which may be valuable if you are considering starting development on TON.

On the TON blockchain, block generation occurs approximately every 5 seconds. This timing remains consistent even as network demand increases. Essentially, within those 5 seconds, the network can handle millions of transactions.

Transacting with Toncoin: A Guide to Payments on the TON Network

On the TON blockchain, block generation occurs approximately every 5 seconds. This timing remains consistent even as network demand increases. Essentially, within those 5 seconds, the network can handle millions of transactions.

Additionally, TON’s blockchain features remarkably low transaction fees.

This setup is generally sufficient for most use cases.

In contrast, traditional banking apps may also process money transfers within seconds, but this is often masked by visual animations.

Reducing block times to, say, 500 milliseconds—like some other blockchains aim to—seems unnecessary for TON. Although technically feasible, such a reduction would require network nodes to handle and store a vast amount of data, which we believe is impractical. Prioritizing nominal performance metrics over practical efficiency is not ideal.

However, there are scenarios where extremely rapid transaction speeds and minimal fees are crucial.

For instance, paying for internet data through TON Proxy or TON Storage might involve fees as low as 0.000000001 TON per kilobyte (these figures are illustrative). Thus, downloading a 1GB file could involve millions of microtransactions, totaling approximately 0.01 TON.

To address this, Payment Channels have been introduced.

Payment Channels

Payment channel technology, also known as the Lightning Network, involves the following steps:

1. Establishing the Channel: Two parties agree to conduct numerous transactions between themselves. They create a dedicated smart contract on the blockchain to which they send their initial deposits. For instance, Alice and Bob set up a payment channel, with Alice depositing 5 TON and Bob depositing 1 TON.
2. Off-Chain Transactions: Alice and Bob can then carry out transactions between themselves off the blockchain. These transactions are signed with cryptographic algorithms to ensure security and validity.
3. Closing the Channel: When Alice and Bob conclude their transactions, they finalize their balances and submit them to the smart contract. This contract then distributes the funds based on their final balances. For example, Alice might receive 4 TON and Bob 2 TON.
4. Cost Efficiency: All transactions within the channel are processed off-chain, resulting in no transaction fees and immediate execution. Network fees are only incurred when opening and closing the payment channel.
5. Contract Assurance: The smart contract ensures proper functioning of the channel. If one party attempts to act dishonestly or disappears, the other party can close the channel independently and claim the funds by providing mathematical proof.

This system allows for efficient and cost-effective transactions while maintaining security and trust.

Resources

A detailed technical overview of payment channels is available in Chapter 5 of the white paper:TON White Paper.

For pre-built smart contracts related to payment channels, visit:Payment Channels on GitHub.

Deep cryptographic knowledge is not required to work with payment channels. You can utilize existing SDKs:

• JavaScript SDK:TON Web SDK
• Example of implementing a payment channel:Payment Channels Example

Payment Channel Networks

As technology evolves, payment channels will be able to form networks off-chain, allowing multiple parties to participate in a single channel. Current smart contracts are already equipped to facilitate integration into such off-chain networks.

Summary

The TON blockchain offers fast transactions and low fees. For extremely rapid transaction speeds and numerous transactions with no fees, payment channels provide an effective solution.

The TON Payments technology has broad applications across various domains, including internet data payments, streaming services, gaming, and decentralized finance (DeFi).

In 2015, the Ethereum blockchain introduced the ERC-20 standard, which enabled users to create their own tokens (cryptocurrencies) within the network.

A few years later, in 2018, the ERC-721 standard was launched for NFTs, which serve as proof of ownership for digital assets.

These standards have led to the rise of decentralized finance (DeFi). In the DeFi ecosystem, operations such as trading, buying, and selling digital assets are executed entirely through blockchain-based smart contracts.

Unlike centralized exchanges, where you temporarily relinquish control of your assets to the platform, decentralized exchanges and DeFi services offer protection against potential risks. Centralized platforms can be vulnerable to hacking, system failures, or data center issues, which can result in the loss of your funds. Additionally, exchanges may impose restrictions on your assets without justification.

This has led to a growing trend towards decentralized exchanges (DEXs), liquidity pools, and other DeFi solutions that offer resilience against these vulnerabilities.

Scalable DeFi Solutions

One of TON’s primary objectives is to facilitate widespread adoption of decentralized technology.

Interest in blockchain and cryptocurrency continues to grow, but these technologies are still utilized by only a small fraction of the global population.

To achieve mass adoption and support billions of users and transactions, we have developed an innovative approach to token and DeFi design.

In contrast to other blockchains, where a token is typically represented by a single smart contract, TON employs a more scalable model.

For instance, the USDT token on Ethereum manages the balances of 4 million users within a single smart contract. Similarly, the Ethereum network’s Bored Ape NFT collection, consisting of 10,000 items, is housed in a single contract.

This approach is commonly used across various blockchain projects to maintain compatibility with Ethereum. However, as the user base grows, this single-contract model becomes a bottleneck, potentially leading to system failures under heavy loads.

TON’s architecture avoids these limitations by decentralizing the management of tokens and NFTs. Each NFT in a collection is assigned its own smart contract, and individual token balances are managed through separate user wallets.

This design enables direct interaction between smart contracts, distributing the load across the network and ensuring balanced performance even as the number of users and transactions scales.

TON also incorporates an infinite sharding mechanism, which splits the network into subchains to handle increased demand efficiently. This flatter load distribution enhances the effectiveness of the sharding process.

Minting an NFT on TON is approximately 500 times cheaper than on Ethereum. Despite fluctuations in the value of Toncoin, network fees remain stable.

Thanks to its distributed architecture, TON maintains high transaction speeds even as the volume of transactions increases dramatically.

Innovation and Advancement

TON has introduced novel concepts that were not present in earlier blockchain technologies.

In the past three months, we have been diligently searching for effective methods to implement scalable DeFi solutions within the TON ecosystem.

Initially, we faced challenges in adapting tokens and DeFi to The Open Network due to the need to rethink approaches for new distributed, asynchronous paradigms.

However, we eventually succeeded. We are now excited to unveil established standards and practical examples of smart contract implementations for Fungible, Semi-Fungible, and Non-Fungible Tokens, as well as contracts for marketplaces and ICOs.

These resources are available for creating DeFi services capable of handling a vast user base. New methods bring new opportunities, and we have already begun exploring them.

We believe that distributed, asynchronous DeFi on TON represents a significant step toward widespread adoption of decentralized technologies.

The TON project extends beyond merely being a blockchain; it encompasses a distinctive network technology.

Initially, the network protocols were specifically designed for the TON blockchain to enable effective communication and data exchange between nodes. Today, the network offers solutions that are so robust and versatile that they collectively represent a new generation of internet infrastructure.

Even when considered separately from the TON blockchain, the TON network stands out as a fully decentralized, secure, and private computing network, similar to TOR or the I2P (Invisible Internet Project).

The TON network is intricately linked with the TON blockchain, its native Toncoin cryptocurrency, and various TON services. This integration creates a powerful synergy, advancing the network’s technology to unprecedented levels.

TON Network Features

• Decentralized: Operates as a peer-to-peer network without any centralized servers.
• Robust: The network remains functional even if some nodes go offline.
• Anonymous: Identifying a node’s IP address is either impossible or extremely challenging.
• Encrypted: All data transmitted between nodes is encrypted.

The network utilizes UDP/IP and TCP/IP protocols for internet communication. For a more in-depth technical overview of these protocols, refer to Chapter 3 of The Open Network’s white paper.

The TON blockchain relies on the TON network. Since the project’s launch three years ago, the nodes (including validators and servers) have effectively communicated through the TON network, demonstrating its stability and efficiency.

As blockchain operations grow in complexity, more advanced network solutions will be necessary. The TON network is well-suited to meet the demands of next-generation blockchains. For instance, when the TON blockchain scales into multiple sub-blockchains to handle high throughput, each sub-blockchain operates within its own dedicated sub-network.

TON Sites

The TON blockchain extends beyond just blockchain applications. From now on, you can set up a web server and host your site on the TON network—essentially creating a TON Site.

Mandatory Encryption and Data Authenticity Verification

In the early days of the internet, data exchanges—such as chat messages—were transmitted in plain text and could be intercepted by anyone on the network. There was no way to ensure that the data wasn’t altered during transmission.

The advent of HTTPS changed this by providing encryption and authentication for data.

Although HTTPS has become widespread over the past 15 years, approximately 20% of websites still do not use this protocol by default.

Consequently, there remains a risk that users’ data might be transmitted through unencrypted channels.

To address this, the TON network enforces mandatory encryption and automatically verifies the authenticity of all data traffic.

Eliminating the Need for Certification Authorities

To secure data and verify its authenticity, traditional websites require special certificates. While you can technically generate these certificates yourself, they may not be trusted as highly as those issued by certification authorities. These authorities, which may charge a fee or offer free services, are supposed to verify the site owner, but often even costly extended certificates lack proper diligence.

In essence, many certification authorities fall short of their responsibilities.

TON Sites simplify this by incorporating built-in cryptographic measures to ensure data encryption and authenticity. Your site will be secure immediately, without the need to engage with certification authorities.

Say Goodbye to Domain Name Registries

For traditional websites, domain names are rented from commercial entities, essentially centralized domain name registries.

A major issue with this system is that your domain name can be suspended or revoked for arbitrary or unknown reasons, or even by mistake.

Anyone can report to a domain name registry that your website is involved in illegal activities. Even if this claim is false, the registry’s staff might be forced to suspend your site without a full investigation into the situation, leading to significant trouble and financial losses.

TON Sites eliminates this problem by using TON DNS, a completely decentralized domain name system.

Unlike traditional registries, which require substantial payments to cover administrative costs, TON DNS only requires a minimal annual micropayment as a token of domain ownership.

Connecting a TON Site to a Domain

Subdomains

Just like with conventional websites, you can create subdomains for your TON Sites using TON DNS.

To achieve this, you can utilize any compatible smart contract.

We have developed several pre-built smart contracts for this purpose.

With the manual-dns smart contract, a site owner can assign any page to any subdomain.

For service providers, the auto-dns smart contract is available. This allows users to register their own subdomains by paying a network fee and an optional service fee.

For example, a social network like place.ton enables Alice to register a personal subdomain, such as alice.place.ton, by paying a small amount of Toncoin.

Additionally, you can conduct an auction for NFT subdomains, similar to the initial distribution of “.ton” domains.

TON WWW

Assigning a Wallet to Your Domain

Imagine you visithttp://foundation.ton and wish to contribute 10 TON to support network development. How would you proceed?

It’s straightforward: Simply transfer 10 TON directly from your wallet to the domain address. No additional payments or details are necessary.

The same applies to subdomains. For instance, if you visit Alice’s personal page at alice.place.ton on the place.ton social network, you can send 10 TON as a gift by entering alice.place.ton as the recipient address. Alice will receive the TON in her cryptocurrency wallet, which she linked to her account during its creation.

Authentication

On the traditional internet, users must register and create unique passwords for each site. This process can become cumbersome and inconvenient, even with the use of password managers. Many users resort to using the same password across multiple sites, which poses significant security risks.

Additionally, logging in often requires an email address or phone number, which can attract unwanted advertisements.

With TON, there’s no need for registration. You can log in to websites or applications using your TON-based crypto wallet, eliminating the need to share your email address or create multiple passwords for different services.

Hyperlinks

The World Wide Web consists of interconnected web pages where text can include hyperlinks. These links allow users to navigate seamlessly from one resource to another or to perform actions such as opening an email client.

TON Sites function similarly to traditional websites, but they are accessed through the TON network. Their URLs resemble those of regular websites but end with “.ton” — for example,http://foundation.ton.

TON uses a distinct format for hyperlinks to trigger actions:

ton://domain/<method>?<field1>=<value1>&<field2>;..

For instance: ton://EQCD39VS5jcptHL8vMjEXrzGaRcCVYto7HUn4bpAOg8xqB2N/transfer?amount=1&text=hello

Clicking this link will launch the TON crypto wallet, pre-filling the recipient’s address, the amount of crypto, and any additional information.

Web developers can also create scripts that interact with your TON wallet or TON browser extension.

This framework forms TON WWW: a network of interconnected web pages and services on TON, accessible through a TON crypto wallet and web browser.

TON Proxy

To access the TON network, users must connect through a specific entry point known as an “entry proxy.”

Currently, the TON Foundation provides public entry points.

These public entry points should be used with HTTP for testing purposes only, as traffic outside the TON network is not encrypted in this case.

Tech-savvy users can already set up entry proxies on their devices. In the near future, this functionality will be simplified and made available to all users via a straightforward application.

Using a Browser

Since TON Proxy supports HTTP Proxy, you can configure your browser or system settings to use a public TON entry proxy as your proxy server.

This setup allows you to access “.ton” sites directly in your browser, just like any other website.

For detailed instructions on configuring TON Proxy across different browsers, refer to the provided guide.

Wallets

Simplifying access is always a goal. Several TON wallets are working on integrating TON Proxy directly into their apps, eliminating the need for additional software.

Currently, this functionality is available via the MyTonWallet Google Chrome extension: switch to TON Proxy, and your browser will be able to access TON sites.

In the near future, this feature will also be incorporated into the standard TON Chrome Extension, Tonkeeper, and other TON wallet applications.

Upcoming Developments

We are anticipating two major updates focused on enhancing privacy and expanding decentralized finance capabilities.

TON Proxy 2.0 — Enhanced Privacy

A major concern with the current internet is that both users’ IP addresses and website IPs are exposed and easily traceable.

With the TON Proxy 2.0 upgrade, users will have the ability to set up intermediary proxy nodes within the TON network. This update introduces garlic routing, which routes data through a series of intermediary nodes, effectively concealing the IP addresses of both users and sites.

Anyone will have the opportunity to operate these intermediary nodes, similar to TOR or I2P. This will enable widespread experimentation with the technology.

Site Security

Many websites, especially beyond the homepage, rely on services like CloudFlare or Akamai to obscure their IP addresses and defend against DDoS attacks and breaches.

While these services are effective, they are centralized commercial entities. These companies control a significant portion of the internet, and a major issue with one can result in widespread outages, impacting a large part of the web.

We believe that utilizing decentralized nodes via TON Proxy offers a more robust and reliable solution for protecting a site’s IP address.

User Privacy Protection

Typically, a user’s IP address is visible and can be exploited by hackers or corporations to gather extensive information about online activities. Corporations can track your browsing history even without user accounts by analyzing IP addresses.

TON Proxy addresses this issue by rerouting internet traffic through multiple intermediary proxies, ensuring that the destination site or service cannot see your real IP address.

With the introduction of TON Proxy 2.0, complete anonymity will be achievable within the TON network.

TON Proxy 3.0 — Advancing Decentralized Finance

In the third phase, the decentralized Toncoin economy will be integrated with intermediary TON Proxies to enhance user privacy and site security.

Payments will be processed through the Payment Network technology, developed in Q2 2022. Intermediary proxy nodes will earn micropayments for handling internet traffic — for instance, for each 128 KiB package — which will be deducted from users’ crypto wallets.

This decentralized payment model will allow independent administrators to manage intermediary proxy nodes globally, improving the network’s efficiency, scalability, and stability.

We believe that the lack of financial incentives has hindered the scalability of networks like I2P and TOR over the past 20 years.

Conclusion

The current internet operates on protocols dating back to the 1990s, and some even from the 1980s. While these foundational technologies have served us well, they are increasingly inadequate in addressing modern privacy and security demands.

As technology becomes more integrated into our daily lives — through surveillance cameras, fitness trackers, and automated checkout systems — the risks to personal information grow. Misuse of this data can lead to severe consequences, including threats to personal safety.

Moreover, the concentration of power among major corporations has made the internet more fragile and privacy-compromising, as vast amounts of user data are collected, sold, or exposed in data breaches.

Today, we take a significant step towards addressing these challenges by introducing the TON network, featuring TON Proxy and TON Sites with TON DNS integration. These decentralized, secure, and user-friendly services offer a superior alternative to the traditional web.

This post serves as an introduction to our work and explores the distinctive aspects of blockchain technology and its applications. We will also clarify fundamental concepts such as smart contracts and gas fees. If you’re new to these topics, this guide is an ideal starting point.

The Traditional Internet (Web2)

The term Web 2.0 refers to the conventional internet that we are familiar with today. This version of the internet is predominantly managed by major corporations like Google. These entities are primarily driven by the goal of maximizing profits for their shareholders, with the welfare of users being a secondary consideration.

Consider a Web2 service like Gmail. As a user of Gmail, you are not on equal footing with Google, the service provider. This phenomenon is known as centralization. In centralized systems, users do not possess genuine ownership. For example, if Google deems that you have violated its terms of service, it has the authority to revoke your access to your email account. Centralized services are also permission-based; you need explicit approval to use the service and send emails. If Google categorizes your email as spam, it is under no obligation to deliver it.

Centralization relies on trust. Users grant power to companies like Google based on their confidence in these entities to handle this power responsibly.

The Next Generation Internet (Web3)

Many of us consider the Internet as a shared resource, a medium that connects the world into a cohesive global community and facilitates communication and collaboration. We envision a future where control shifts from large corporations to individual users. Web3 embodies this vision, representing the anticipated next phase in the evolution of the Internet.

In this vision, users of Web3 services have the same level of authority as the creators of those services. This principle, known as decentralization, ensures that users have genuine ownership—not just of their data but also of digital assets. For instance, your cryptocurrencies like Bitcoin or Toncoin are fully yours and cannot be seized by anyone. Decentralized services also operate on a permissionless basis, meaning you can transfer your Toncoin or perform other transactions without needing approval from anyone else. No one can block or censor your actions.

Decentralization enables systems to be trustless. With no central authority, there is no risk of abuse of power that could harm users.

Blockchain Technology

The concept of Web3 appears promising, but how practical is it? For developers, creating services where the user and provider are on equal footing can be challenging. Typically, developing a service involves setting up a backend that operates on a server owned by the developer. This server can be modified or even shut down by the developer, leading to an unequal relationship. Traditional backend servers are centralized.

Blockchain technology was designed to address this issue, enabling the creation of decentralized backends. In a blockchain system, the backend is maintained by its users. This equal relationship means that any user interested in contributing to the backend can do so, with the blockchain functioning as a cooperative effort among its participants.

Collaboration in blockchain networks is managed through consensus. For an outcome to be validated, it must be agreed upon by a majority of users. This process makes blockchains less efficient compared to traditional centralized servers, as each calculation requires confirmation from multiple participants. Additionally, operating blockchains can be more costly due to their inherent inefficiencies.

The Token

We previously discussed how results are validated through voting. But how does this voting system function? Is it a straightforward “one user, one vote” model like in traditional elections? In practice, this approach is impractical on the Internet due to a challenge known as the Sybil attack. It’s easy to create numerous fake identities online. Given the decentralized nature of Web3, we lack a centralized authority to differentiate between genuine and fraudulent users.

A common decentralized approach to addressing this issue is to tie voting power to a token. For instance, if you possess 10 tokens, you are granted 10 votes. Unlike fake identities, tokens are difficult to counterfeit, making it easy to distinguish legitimate tokens from fraudulent ones. The TON blockchain utilizes Toncoin, while the Ethereum blockchain uses Ether. This implies that every blockchain operates as an economy in its own right. Tokens serve as an incentive to ensure that the decentralized network remains aligned with its goals.

Network Validators

Blockchains function as networks managed by a group of users. Those who handle the core operations and participate in the consensus process are known as validators. The influence of each validator in the voting process is proportional to the number of tokens they hold. To ensure validator integrity, they typically must stake their tokens. Should the consensus process determine a validator is acting dishonestly, their staked tokens may be forfeited as a penalty. This system of governance is known as proof-of-stake.

Being a validator is demanding, requiring the operation of a blockchain node on a personal server and staking a significant amount of tokens. Users with fewer tokens who wish to participate can delegate their tokens to a more prominent validator. These users are referred to as nominators.

Transaction Fees

As previously mentioned, blockchains function as economies. The infrastructure necessary for validators is not free, so they must be compensated for their services. Payments are made using the blockchain’s native token. For example, on the TON blockchain, users pay fees with Toncoin. Validators earn Toncoin for processing transactions and running applications on the blockchain.

When a user performs an action on the blockchain, they initiate a transaction that includes a fee known as gas. This concept is analogous to a car needing fuel to operate. Users must authorize transactions using their blockchain wallets, which ensures that only the wallet’s owner can approve the payment of gas and finalize the transaction.

Decentralized Applications (Dapps)

As we previously mentioned, blockchains are designed to operate decentralized backends. These blockchain-based services are commonly referred to as apps, or more specifically, decentralized apps, abbreviated as dapps. Developers create dapps, which are executed by network validators. Users engage with dapps by sending transactions to them. In a decentralized system, the developer of a dapp has the same status as its users, with no special privileges.

To illustrate this, consider a traditional Web2 service such as Google Search. The provider of this service, Google, controls search result rankings for user benefit but can also promote its own products. For instance, when searching for “storage,” Google might prioritize “Google Drive” over “Dropbox.” In a Web3 version of Google Search, the developer would not have the ability to favor their own products in the search results.

Smart Contracts

In the Web2 world, services like Google Search come with terms of service. If users feel wronged, they can seek judicial resolution. Web3 operates differently, lacking centralized authority figures like judges. Instead, the code governs the rules. In this context, the code of a dapp serves as the binding agreement between its users. Unlike traditional legal contracts, this code executes consistently and is not open to interpretation.

Blockchain technology substitutes traditional legal agreements with code. This code, known as a smart contract, defines the terms of the dapp. Users are expected to review the smart contract’s source code before participating, just as one would thoroughly read a lease agreement before signing it. Communities often assist each other in this process since not all users have the technical expertise to review code independently.

Once a smart contract is written, deploying it to the blockchain makes it accessible to everyone. This deployment process involves publishing the contract code to the blockchain, where it is identifiable by its contract address.

Blocks and Explorers

Previously, we discussed how network validators are required to vote on the outcome of each transaction. To simplify this process, transactions are grouped into blocks. Each block is assigned a unique block number and undergoes a consensus process, requiring approval from a majority of validators. Arranging these blocks sequentially forms a chain—hence the term “blockchain.”

After initiating a transaction, users must wait for it to be included in a block. On the TON blockchain, a new block is created approximately every 5 seconds. Users can track transactions, verify their success, and identify which block they were included in using a tool known as a block explorer, or simply an explorer.

The Practical Value of Blockchain

In this discussion, we have primarily explored the concept of blockchain and defined key terms. While the technology may seem complex and abstract, it offers practical benefits. Can we provide a concrete example of how blockchain can enhance daily life?

In 2018, I published a two-part series on this topic. Part 1 is titled “How Blockchain Can Assist You on a Deserted Island,” and Part 2 is “How to Operate a Blockchain on a Deserted Island with Pen and Paper.” If you enjoyed the TV series Lost, you might find these articles intriguing.

Happy coding!

Tal is the founder of Orbs Network. He is an enthusiastic blockchain developer, advocate of open-source projects, and contributor to the TON ecosystem. Follow Tal on GitHub and Twitter. If you notice any errors in this post, please reach out to Tal on Telegram.

In this guide, we’ll create a fundamental storage contract that an administrator can update and use to retrieve stored data. This tutorial is the first in the “Step-by-Step with Rift” series, focusing on foundational concepts in Rift.

Getting Started

Install Rift

To start, ensure you have Python 3.10 or higher installed. Then, install Rift with the following command:

Initialize the Project

Open your terminal and run the command below to set up a new project:

The –base option determines the template used for the initial setup. You should see a confirmation message like this:

Project Structure

After setting up your project, open the directory in your preferred editor or IDE. If you don’t have one, we recommend using VSCode. The project directory structure will look like this:

Project Setup

The project setup details are found in the project.toml file. This file must be updated to define new targets, include test and deployment scripts, or adjust Rift’s configuration. Below are the contents of this file:

Contracts Directory

All of your contract files will be located in the contracts/ directory. These contracts are implemented as classes that extend the base Contract class. The code within these contracts is executed, and the execution flow is tracked and translated into FunC (and eventually TVM). Any operations that cannot be traced will still be recorded in the execution results. For more in-depth information, refer to the documentation here.

Tests

Test scripts should be placed in the tests/ directory. Make sure to list the test script in your target configuration file. These scripts are straightforward Python files; you can import contracts from the contracts package and utilize standard Python code for testing purposes.

Deployers

Deployment scripts should be located in the deployers/ directory. The script specified in your target configuration will be executed whenever you run the command rift deploy [TARGET].

Storage Contract

Specifications

In this section, we will create a storage contract designed to hold an unsigned 64-bit integer value. The contract will have the following features:

• The admin of the contract will be able to update this value by sending an internal message.
• A get-method will be provided to access the stored data.

1. Configure the Project

We’ll start by restructuring the existing files. Rename contracts/bare_template.py to contracts/storage.py and update its contents as follows:

The next step is to make the necessary adjustments to the project configuration in project.toml in order to reflect the aforementioned changes.

2. Define the Contract Data

Add the Data class to the Storage class to define the structure of the. This class should extend Model:

3. Define the contract message structure

Specify the structure of the contract message body by adding a Payload class:

4. Implement the change Function

In the internal_receive function, check if the sender is the admin and update the data with the new value. You can access the full message via self.message and the message body with self.body:

5. Specify the get-method

Define a get-method to expose the value. There are two approaches:

• Automatic Handling: Add a configuration docstring to the class for automatic handling during compile time:

This method is suitable for directly exposing a field without additional processing.

• Manual Method Definition: Define a new method in the contract with the @method_id() annotation:

6. Finalise

Your contract is now complete. Compile it using the following command:

The compiled files will be located in the build/ directory.

Testing

A crucial component of developing contracts is verifying their accuracy and security. Even small errors can lead to substantial financial repercussions for those involved. Thus, thorough testing with well-designed test cases is a vital part of the development process. Fortunately, Rift offers an integrated testing framework that simplifies the process of testing contracts.

To start, rename the tests/test_example.py file to tests/test_storage.py and update it with the following code:

In the testing setup, we can effortlessly import the target contract and create an instance using any cell as its initial data. Afterward, we can invoke its methods and evaluate the outcomes.

To start, we’ll test the get_value method to verify that it accurately retrieves data from our cell:

To test the get_value method, we first create a Storage instance with an initial data cell containing the admin address and a value of 1. We then call the get_value method and verify that it correctly returns the value:

Next, we will test the internal_receive method to ensure it correctly handles the change_value call. We will create a message to update the value and check if the new value is reflected:

We should also verify that the contract does not allow unauthorized changes by testing with a different admin address:

To execute the tests, use the following command in the terminal:

The output should reflect the test results accordingly.

Deploying the Contract

In this revised deployment function, we first obtain our wallet and its address. We then prepare the initial contract data, which includes the admin address and sets the initial value to 0. Next, we create an initial message for the contract, setting the new value to 1. Finally, we submit the deployment request with 0.1 TON allocated for fees.

To deploy the contract on the testnet, use the following command:

On your first attempt, you will need to set up a wallet with Rift and ensure it is funded. Once you execute the command, you should receive a confirmation message indicating that the contract is being deployed to a specific address.

Conclusion

This tutorial has guided you through the process of developing and deploying a basic storage contract on the testnet using Rift. This serves as a foundation for future development tutorials with Rift. You can access the full project implementation here. For updates and to join our community, check out our channel. We focus on providing clear, step-by-step guides and continuously update our documentation. Stay tuned for more!

There are several straightforward methods for acquiring and immediately utilizing USDt on TON. One of the most accessible and efficient ways to purchase USDt is directly through Telegram using the Wallet feature. This approach streamlines the buying process and swiftly deposits your USDt into your Wallet, enabling seamless, global transfers to your contacts without any hassle.

Here’s a detailed guide on how to buy USDt using the Wallet feature in Telegram:

1. Access Wallet: Launch Telegram and navigate to the Wallet feature. If you’re using it for the first time, follow the on-screen prompts to set up your wallet.
2. Navigate to ‘Add Crypto’: Select your preferred payment method, either a bank card or the P2P marketplace.
3. Choose USDt-TON and Specify Amount: Select USDt-TON as your currency and enter the desired amount to purchase. You can specify the amount in USDt or its equivalent in your local currency.
4. Confirm and Finalize: Confirm your purchase details to complete the transaction. Your USDt-TON will be instantly credited to your Wallet.

Why Wallet in Telegram is the Preferred Choice:

• Immediate Integration: Buying USDt via Wallet results in immediate deposit into your Telegram Wallet, ready for instant use.
• Fee-Free Global Transfers: Transfer your USDt on TON to any Telegram contact worldwide without incurring transaction fees.
• Simplicity and Security: The process is straightforward and secure, eliminating the need for complex cryptocurrency exchanges.

Please be aware that USDt on TON is not accessible to users residing in mainland US, US territories, or citizens of the United States and other restricted countries as outlined in Tether’s Terms of Service.

Discover the various wallets available within the TON Ecosystem designed to secure your digital assets. This guide will walk you through using different types of wallets, including Tonkeeper, one of the most popular options.

We will also cover some non-custodial wallets and the @wallet custodial service. If you’re unfamiliar with the differences between these wallet types, you can refer to this post for more details.

Non-custodial wallets allow users full control over their cryptocurrency, ensuring no third party can access, freeze, or block your account. In contrast, custodial wallets keep your coins with a custodian—similar to a traditional bank account managed through a mobile app. While custodial wallets are generally less secure, they offer greater convenience and are more user-friendly for beginners.

@wallet: A Convenient Custodial Option

Among the wallets we’ll discuss, @wallet is the only custodial wallet. Operated independently within the TON ecosystem, @wallet provides a user-friendly experience directly integrated with your Telegram app. It simplifies the process of managing your cryptocurrency by eliminating the complexities of non-custodial wallets and the need to manage private keys.

Features of @wallet:

• Quick Account Setup: Create an account in under a minute without leaving Telegram.
• User-Friendly Interface: Manage your crypto assets easily through an intuitive web interface.
• Seamless Transactions: Store, receive, and send Toncoin with a single click in Telegram chats.
• Token Management: Store, receive, and send Tether (USDT) and exchange it for Toncoin (TON) directly within the app.

For those new to cryptocurrency, @wallet offers a straightforward introduction to the blockchain world, making it an excellent choice for beginners.

Tonkeeper: A Leading Non-Custodial Wallet

Tonkeeper is one of the most well-regarded non-custodial wallets in the TON ecosystem. It offers a range of features designed to enhance your cryptocurrency experience. At the end of this guide, you’ll find a brief tutorial on how to install and use Tonkeeper.

Key Features of Tonkeeper:

• Decentralized Browser: Tonkeeper allows you to interact with various decentralized applications (dApps) within the TON network. For instance, you can purchase TON NFTs directly through your wallet.
• Fast Performance: The app is designed for speed and efficiency.
• User-Friendly Interface: It boasts an intuitive design that simplifies wallet management.
• Built-in Transactions: Easily buy, sell, and exchange Toncoin.
• NFT and Altcoin Support: Tonkeeper can store and transfer NFTs and altcoins based on the TON blockchain.

OpenMask: The TON Alternative to MetaMask

For those with prior experience in cryptocurrency, OpenMask will feel familiar as it is the TON equivalent of MetaMask, a widely-used browser wallet.

Key Features of OpenMask:

• Familiar Interface: OpenMask mirrors the architecture of MetaMask but incorporates modern updates.
• Support from TON Foundation: OpenMask is supported by the TON Foundation and is developed with open-source principles.
• Ideal for Desktop Users: If you are accustomed to managing crypto via a computer and Google Chrome, OpenMask is an excellent choice.

SafePal: Premier Hardware Wallet

SafePal was the first hardware wallet to support Toncoin, offering a secure cold storage solution for your digital assets. A hardware wallet is a physical device, similar in size to a USB flash drive, that ensures your coins are kept secure.

Key Features of SafePal:

• Enhanced Security: Cold storage is widely regarded as the most secure method for storing digital assets.
• Multilingual and Versatile: Supports 15 languages and over 54 blockchains, accommodating a vast range of cryptocurrencies.
• Global Reach: With more than 6 million users across 196 countries, SafePal provides a reliable option for those looking to store substantial amounts of crypto securely.

Tonhub: A Versatile Non-Custodial Wallet

Tonhub is a sophisticated non-custodial wallet developed by the TON Whales team. For installation, follow the provided instructions.

Distinctive Features of Tonhub:

• Toncoin Staking: Easily stake Toncoin directly through the app’s interface.
• Token Builder: This feature allows users to create their own cryptocurrencies on the TON blockchain, though it’s currently available only to TON Whales club members.

TON Wallet: Simplified for Basic Transactions

TON Wallet is designed with simplicity in mind, offering limited features primarily for storing and transferring Toncoin.

Key Points:

• Basic Functionality: Ideal for users who need an app for straightforward coin transfers.
• Future Enhancements: A competition is underway to develop an updated version of TON Wallet, promising new features in the coming months.

MyTonWallet: A Comprehensive Non-Custodial Solution

MyTonWallet is another non-custodial wallet available as both a mobile app and a Chrome browser extension.

Features of MyTonWallet:

• Versatile Storage: Supports Toncoin, TON-based altcoins, and TON NFTs, similar to general crypto wallets.
• Staking Capability: MyTonWallet was the first to offer staking functionality through an official smart contract. Users holding 10,000 or more Toncoin can currently stake their coins via MyTonWallet. A new smart contract update is expected soon, which will lower the deposit threshold.

C98 and Math Wallet: Multi-Chain Non-Custodial Options

While C98 and Math Wallet are not native to the TON Ecosystem, they are compatible with The Open Network (TON) and Toncoin.

If you are already using either of these multi-chain wallets, you can easily store and manage your Toncoin within them. For more information, visit:Coin98.

If you’re new to the TON Ecosystem, we recommend starting with one of the wallets listed earlier, such as Tonkeeper.

How to Set Up Your Tonkeeper Account

Step 1: Download the Tonkeeper Wallet

Visit the Tonkeeper website or search for it in your app store to download the latest version of the wallet.

Step 2: Create a New Wallet and Record Your Seed Phrase

A seed phrase consists of 24 words that function as a password for non-custodial cryptocurrency wallets. Write down these 24 words in the exact order on a piece of paper. This seed phrase is crucial for restoring your wallet if you ever lose the app. Store it securely—losing the seed phrase means losing access to your assets permanently.

Avoid saving the seed phrase on your computer or phone to prevent exposure to malicious software.

Step 3: Confirm Your Seed Phrase

Re-enter the words in the correct sequence to verify the accuracy of your seed phrase.

Step 4: Set and Confirm a Passcode

Create a passcode to access your wallet, similar to those used in other applications.

And you’re all set! Your Tonkeeper wallet is now ready for use.

How to Acquire Your First Toncoin

The simplest method to purchase Toncoin is likely through Tonkeeper. To do so, navigate to the “Browser → Exchanges” tab within the app and choose an exchange service.

However, there are numerous ways to acquire TON, many of which are detailed in this guide.

Tonkeeper: Beyond a Simple Wallet

Tonkeeper is more than just a cryptocurrency wallet—it’s a comprehensive Web3 platform with a wide range of features. We suggest exploring the app to see how you can manage your NFTs and other TON-based tokens, interact with decentralized applications such as NFT marketplaces and decentralized exchanges (DEXs), and invest in TON projects.

Conclusion

The TON Ecosystem offers a diverse selection of wallets, each with its distinct features and functions. We provide several user-friendly options to help you access the world of blockchain and cryptocurrency, regardless of your experience level. Getting started is just a few clicks away!

Remember, your 24-word seed phrase can be used with any of the TON wallets mentioned above, allowing for seamless transitions between services. If you find one service isn’t meeting your needs, switching to another is straightforward.

You can find the full list of TON wallets here:TON Wallets.

Please ensure that you only download and use wallets listed on official TON resources.

This content is produced by TONRadar, an independent third-party initiative. TONRadar is a community-driven aggregator focused on exploring decentralized applications (dApps) and projects within the TON ecosystem.

Introduction to The Open Network (TON)

Welcome to the beginner’s guide to The Open Network (TON), an innovative blockchain project that has captured significant interest in the cryptocurrency and decentralized systems arena. In this article, we’ll delve into what TON is, its core features, and its potential impact on the blockchain industry.

What is TON?

TON, which stands for The Open Network, is a blockchain-based decentralized network technology. Initially developed by the Telegram team, TON was created to be a robust and scalable blockchain platform. Launched in 2018, the project experienced a temporary suspension but resumed under the TON Foundation, with a rebranding from Telegram Open Network to The Open Network.

TON functions as a Layer 1 blockchain, similar to well-known blockchain networks like Solana and Ethereum. It employs a proof-of-stake (PoS) consensus mechanism, where nodes can become validators by staking Toncoin. Validators play a crucial role in securing the network and validating transactions, earning Toncoin as a reward for their efforts.

The TON ecosystem is built to accommodate millions of users, focusing on efficiency, speed, and scalability to offer a user-friendly experience.

It’s worth noting that in May 2020, Telegram exited the TON project due to legal issues with the US Securities and Exchange Commission. Despite this, the technology and vision behind TON continue to influence the development of blockchain and decentralized networks.

How TON Functions

TON operates through a distinctive combination of architectural elements and consensus mechanisms designed to ensure fast, scalable, and secure transaction processing. Here’s a high-level overview of how TON works:

Architecture

TON is organized as a multi-layered network, including the masterchain, workchains, and shardchains. The masterchain serves as the central hub, overseeing validator nodes, staked assets, and the synchronization of various network components. Workchains are independent blockchains that support smart contracts and decentralized applications (dApps). Within each workchain, shardchains are used to enhance scalability and parallelize transaction processing.

TON Virtual Machine (TVM)

The TON Virtual Machine (TVM) offers a secure and isolated environment for running smart contracts on the network. It guarantees that contracts execute consistently across all nodes and provides the computational resources needed for complex operations. TVM is essential for upholding the predefined rules and logic coded into smart contracts.

Consensus Mechanism

TON employs a Byzantine Fault Tolerant (BFT) consensus system known as Block-Proof of Stake (BPoS). Validators, who hold and stake TON’s native cryptocurrency, are responsible for block validation and reaching consensus. The BPoS mechanism requires a supermajority of honest validators for block confirmation, thereby bolstering the network’s security and resilience against malicious attacks.

Sharding

Sharding is a pivotal element of TON’s scalability approach. Each Workchain is divided into several Shardchains, which process transactions simultaneously. By distributing the transaction load among multiple Shardchains, TON enhances throughput and scalability. Shardchains manage a portion of the global state, allowing efficient transaction processing without requiring each node to handle every transaction.

Smart Contracts and Apps

Within TON, Workchains support smart contracts—self-executing agreements with predefined conditions and rules. Developers can create decentralized applications (dApps) on TON using these smart contracts. These dApps can facilitate various functions, including decentralized finance (DeFi), gaming, social media, and more. The adaptable design of Workchains promotes innovation and customization in dApp development.

Interoperability and Cross-Chain Communication

TON supports interoperability and cross-chain communication between different Workchains and Shardchains. This feature enables seamless asset transfers and transaction processing across various chains within the TON network. Interoperability fosters collaboration between dApps and the exchange of assets and data, enriching the overall ecosystem and user experience.

Speed and Efficiency

TON is engineered to deliver high-speed and efficient transaction processing. The integration of sharding, parallel processing, and the BFT consensus mechanism ensures a high transaction throughput and rapid confirmation times. This performance is crucial for supporting real-world applications and managing a high volume of transactions while preserving network integrity.

Security and Decentralization

TON places a strong emphasis on security through its advanced consensus mechanisms, cryptographic methods, and network validation processes. The decentralized structure of TON, with validator nodes distributed throughout the network, enhances its resilience against attacks and censorship. The network’s design ensures a high level of decentralization while preserving the security and integrity of transactions and smart contracts. By integrating decentralization, consensus algorithms, sharding, smart contracts, and a specialized virtual machine, TON strives to build a robust and scalable network capable of supporting a diverse range of decentralized applications and services. Despite challenges faced by the original Telegram-driven TON project, other initiatives and communities have continued to advance TON technology, leveraging its foundational principles to develop innovative blockchain solutions.

TON Wallets

TON wallets are digital tools crafted for managing, storing, and transacting Toncoin (TON), the native cryptocurrency of the TON ecosystem. These wallets offer users a secure and efficient means to interact with the TON blockchain and engage in network activities.

TON wallets come in two primary varieties: non-custodial and custodial. Non-custodial wallets, also known as self-custody wallets, give users full control over their funds and private keys. This setup means users are responsible for the security and management of their wallets and assets. Conversely, custodial wallets are managed by third-party service providers who handle the storage and security of users’ funds and private keys, offering convenience but potentially less control.

Tonkeeper is a prominent non-custodial wallet that provides a decentralized and secure way to manage Toncoin. It features an intuitive interface, supports interaction with decentralized TON applications, and allows for the direct buying, selling, and exchanging of Toncoin within the app.

Tonhub, developed by the TON Whales team, is another notable non-custodial wallet. It is distinguished by its sleek design and unique features like Toncoin staking and the Token Builder, which enables users to create their own cryptocurrency based on TON. Tonhub is an appealing choice for those who wish to actively participate in the TON ecosystem.

For users seeking a straightforward solution for basic coin transfers, TON Wallet offers a simple design and limited functionality focused on ease of use for storing and sending Toncoin.

If you prefer a custodial wallet, @wallet could be a suitable option. Integrated directly into the Telegram messaging app, @wallet provides a seamless and convenient way to manage your crypto assets without leaving Telegram. While custodial wallets offer user-friendly access, they involve entrusting a third party with the security of your private keys.

When using any wallet, it’s crucial to follow best practices for security. Ensure you download wallets from official and trusted sources, protect your private keys or seed phrases, and keep your wallet software updated to benefit from the latest security features and fixes.

TON Storage

TON Storage offers a decentralized method for storing data and information on the blockchain. It functions similarly to traditional cloud storage services like Dropbox but enhances security by encrypting data with the user’s wallet private key.

TON Sites

TON Sites enable users to create and host websites on the TON network. This service provides a decentralized, secure, and reliable platform for web hosting, ensuring that websites are accessible through the TON network.

TON WWW

TON WWW encompasses the array of web pages and services available on the TON network. It includes websites that can be accessed using a TON crypto wallet and web browser. TON WWW leverages TON Proxy and TON Sites to offer a secure and decentralized browsing experience.

TON Proxy

TON Proxy is a technology designed to facilitate user access to the TON network. It helps overcome censorship and provides easy entry to decentralized applications (dApps). TON Proxy can be configured in browsers or integrated into TON wallet apps, allowing seamless access to TON Sites.

Smart Contracts

TON employs smart contracts to accelerate transaction processing, akin to other blockchain networks. These smart contracts are executed by the TON Virtual Machine (TVM), ensuring efficient and reliable operation on the TON blockchain.

TON DNS

TON DNS is a service that simplifies the use of crypto wallets, accounts, smart contracts, and other resources within the TON network. It aims to make addresses and access more user-friendly, improving navigation and resource management on the network.

Ton Bridge

Ton Bridge facilitates the exchange of TON coins across different blockchain networks, including Binance Smart Chain and Ethereum. It allows for smooth transfers of TON tokens between these networks.

Conclusion

Despite encountering various challenges, TON has significantly contributed to the advancement and innovation within the blockchain industry. It continues to support the development and expansion of decentralized applications and services, serving as a vital platform for blockchain progress.

As the world of finance and cryptocurrencies continues to evolve, the methods for storing, managing, and accessing digital assets have become increasingly crucial. Central to this discussion is the choice between custodial and non-custodial wallets. Each type offers distinct benefits and challenges that impact security, asset management, and user experience.

This article provides an in-depth exploration of these two types of wallets, clarifying their definitions, advantages, and drawbacks, and examining their suitability for different needs.

Whether you are an experienced investor, a newcomer to the crypto space, or simply interested in the topic, gaining a clear understanding of custodial versus non-custodial wallets will help you make more informed decisions in today’s digital age.

Custodial vs. Non-Custodial Wallets: What They Are and How They Differ

Custodial Wallets

Custodial wallets are services where a third party, such as a financial institution or cryptocurrency exchange, is responsible for holding and managing your private keys.

In this model, you transfer your cryptocurrencies to an address provided by the custodian. The custodian then takes on the role of safeguarding, managing, and securing your assets.

Prominent examples of custodial services include major centralized exchanges like Coinbase and Binance. When you deposit cryptocurrency into your account on these platforms, the exchange holds and manages the funds on your behalf. Unlike non-custodial solutions, you do not have direct access to your private keys with these services; instead, the security and management of your assets are handled by the platform itself. This is similar to how traditional banks operate—once your money is deposited, it is no longer under your direct control.

Non-Custodial Wallets

The concept of “Not your keys, not your coins” is fundamental in the world of cryptocurrency. Non-custodial wallets and services are designed to ensure that you retain ownership of your private keys and, consequently, your crypto assets. In this model, the responsibility for the security, safekeeping, and management of your assets rests solely with you.

Non-custodial solutions involve storing your assets in wallets where only you have access to your private keys. This setup allows you to manage, send, and receive your cryptocurrencies independently, without relying on intermediaries or third-party services.

Prominent examples of non-custodial solutions include hardware wallets such as Ledger and Trezor, as well as software wallets like Tonkeeper and Trust Wallet. With these options, you retain full control over your private keys and your assets. No external party can access or manage your funds without your explicit authorization, which is protected by your private key.

Custodial Wallets

Advantages:

• Enhanced Security: Centralized custodial services typically invest significantly in robust security measures to safeguard large volumes of assets. This can offer a higher level of security compared to what many users could achieve on their own, particularly for those less familiar with technology.
• User-Friendly Experience: For those new to cryptocurrencies, custodial solutions often provide a more straightforward and intuitive interface. These platforms manage complex processes behind the scenes, simplifying tasks like trading, withdrawing, and depositing for users.
• Customer Support: Custodial services generally offer customer support teams available to help with issues such as lost passwords or transaction problems.
• Regular Updates and Features: Many custodial platforms regularly update their systems with new features, improved user interfaces, and additional functionalities to enhance user experience.

Disadvantages:

• Centralization Risks: Centralized custodial platforms, such as exchanges, can be prime targets for hackers. Centralization also introduces a single point of failure, which can pose risks.
• Limited Control: In custodial solutions, you do not have direct control over your assets. The platform manages your funds, and you must rely on its integrity.
• Potential Censorship and Restrictions: Custodial platforms can freeze accounts or restrict access to funds under certain circumstances, such as government requests, suspicious activities, or their own policies.
• Privacy Issues: Centralized platforms often link your identity to your accounts, which can expose your transaction history and balances more than in non-custodial solutions.

Non-Custodial Wallets

Advantages:

• Complete Control: You retain full authority over your assets. No third party can access or manage your funds without your private key or the device where they are stored.
• Resistance to Censorship: With no central authority overseeing transactions, there is a lower risk of your funds being frozen or restricted.
• Increased Privacy: Non-custodial solutions offer greater privacy since there is no central entity tracking all transactions. Although blockchain transactions are generally public, the identities associated with these transactions can remain pseudonymous.
• Reduced Intermediary Risks: You face fewer concerns about the platform going offline, being compromised by hackers, or encountering regulatory issues that could impact your assets.

Disadvantages:

• Increased Personal Responsibility: The burden of security falls entirely on you. Losing access to your private keys means losing access to your assets.
• Learning Curve: Non-custodial wallets can be challenging for beginners to navigate. It is crucial to understand seed phrases, private keys, blockchain mechanics, and security practices.
• Limited Support: If an error occurs, such as sending funds to an incorrect address, there is typically no way to recover your assets, and support options may be minimal or non-existent.
• Risk of Loss: Poor management, forgotten credentials, or falling victim to scams can lead to irreversible loss of assets. In non-custodial systems, the security of your funds depends heavily on how well you protect and manage your private keys and recovery seed.

As proponents of decentralized and censorship-resistant solutions, we encourage exploring non-custodial wallets. If you decide to use one, here are some tips to help you become an independent and secure crypto holder.

Security Guidelines for Non-Custodial Wallets

Regular Backups: Make sure to frequently back up your wallet and keep these backups in multiple secure locations to protect against data loss.

Utilize Hardware Wallets: For holding substantial amounts of cryptocurrency, consider using a hardware wallet. These devices keep private keys offline, offering protection against online threats.

Verify Addresses: Always double-check the recipient’s address before transferring funds. Malware can alter copied addresses, so it’s essential to verify the full address thoroughly. Avoid relying solely on the initial and final characters, as malicious addresses can mimic these characters. Verify the entire address twice to ensure accuracy.

Keep Software Updated: Regularly update your wallet software. Developers release security patches and updates, so maintaining the latest version is crucial for safeguarding your assets.

Guidelines for Storing and Securing Your Private Keys and Recovery Seed

Physical Security: Record your recovery seed on paper and store it in a secure place, such as a safe or safety deposit box. Consider using durable materials like steel for recovery seed backups, which offer resistance to natural elements and time, such as CryptoSteel or CryptoTag.

Avoid Digital Copies: Refrain from taking photos or screenshots of your recovery seed, as these can be vulnerable to online threats, especially if stored on internet-connected devices. Prefer physical backups or secure recordings.

Use Tamper-Evident Bags: Place your written recovery seed in tamper-evident bags to detect any unauthorized access attempts.

Create Multiple Copies: Make several copies of your recovery seed and store them in different secure locations. This redundancy ensures that if one copy is lost or damaged, others remain available. For added security, consider splitting the seed (words) into separate locations.

Keep it Confidential: Your recovery seed is crucial for accessing your funds. Do not share or expose it, as this could lead to a loss of assets. Only trusted individuals should know its location and contents.

As digital assets become more mainstream, understanding and implementing robust storage solutions is vital. By following these guidelines, you can ensure the security and accessibility of your holdings.

Conclusion

In the swiftly advancing realm of cryptocurrencies, choosing between custodial and non-custodial options is more than just a matter of preference—it’s a balancing act between convenience and self-reliance.

As we’ve explored, both approaches offer distinct advantages and drawbacks. The ideal choice often hinges on your familiarity with the technology, desired level of control, and tolerance for risk. With decentralization at the heart of the cryptocurrency revolution, non-custodial solutions align closely with the principles of digital assets. However, they also entail significant responsibilities.

There is no need to feel obligated to adopt non-custodial wallets if custodial services better fit your needs. Ultimately, the decision is yours, and protecting your assets and private information is paramount.

Conduct thorough research, consult various sources, and evaluate your circumstances to determine which option aligns best with your requirements.

Stay alert and secure!

In the newly announced TFxTelegram initiative, we’ve outlined the vision of transforming the TON Ecosystem into a SuperApp, where users can engage with numerous projects on a single platform. However, several milestones must be achieved before this vision becomes a reality, with technical feasibility being a major factor.

Creating a blockchain ecosystem that supports millions—or even hundreds of millions—of users while providing a smooth and cost-effective experience is no small feat. We believe that, to date, no blockchain can offer the necessary infrastructure at this scale except The Open Network (TON).

Core Features of The Open Network

One of the key attributes of The Open Network is its capacity for high scalability and throughput. TON accomplishes this through dynamic sharding, dividing the blockchain into multiple shards or shardchains. Each shard operates independently and in parallel, which allows the network to process transactions efficiently.

This dynamic sharding approach enables TON to scale virtually indefinitely, handling millions of transactions per second from billions of users without compromising speed, security, or decentralization.

Overview of TON’s Architecture

Masterchain

The Masterchain is the central chain that maintains the network configuration and the final state of all workchains. It serves as the primary reference for all shards in the ecosystem, storing essential protocol data, validator information, and current block hashes. Essentially, the Masterchain acts as the core directory, ensuring consensus across the network.

Workchain

The Masterchain splits into Workchains, which are customized blockchains designed for specific transactions or use cases. Each Workchain operates in parallel within the TON network, supporting its own rules and tokenomics while synchronizing with the Masterchain for validation and interoperability.

Shardchain

Shardchains are sub-chains within Workchains, identified by a 60-bit shard prefix. This prefix determines which accounts belong to a particular shardchain, allowing efficient transaction processing and scalability. The dynamic nature of sharding allows for the creation, splitting, or merging of shardchains as needed to balance the network’s workload.

Sharding Mechanism

Dynamic sharding is TON’s standout feature, enabling high scalability by distributing transactions across multiple shardchains. Each shardchain periodically reports its state to the Masterchain, and they communicate with each other through Hypercube routing, ensuring seamless transactions throughout the ecosystem.

Validators

Validators play a crucial role in maintaining the integrity and security of the network. They provide computing power and stake Toncoin to validate new blocks and transactions. TON uses a decentralized Proof-of-Stake (PoS) mechanism where validators’ stakes and performance influence their role. This system promotes network resilience and prevents collusion or malicious activities.

Future Prospects

The architecture of The Open Network demonstrates forward-thinking solutions to the scalability and transaction speed issues that challenge many blockchains. TON’s multi-layered structure—from Masterchain to shardchains—optimizes efficiency and security.

As TON Foundation pushes the boundaries of blockchain performance, we’re on the brink of setting new benchmarks. We encourage the community and enthusiasts to join us in this exciting journey as we continue to enhance and expand the TON ecosystem. With a robust architectural foundation, the future promises unprecedented advancements and groundbreaking partnerships.

Blockchain technology has significantly transformed the digital landscape, and The Open Network (TON) has recently achieved a groundbreaking milestone by setting a new record for the fastest blockchain, processing 104,715 transactions per second. This achievement was announced during our live broadcast on October 31, which you can view again on our YouTube channel.

This extraordinary performance opens up new possibilities for leveraging TON’s speed to revolutionize various industries. The primary challenge for Web3 is to offer practical applications and integrate seamlessly with existing Web2 frameworks. With TON’s advanced blockchain infrastructure, we are poised to meet these challenges effectively.

In this article, we will delve into six practical applications that highlight the transformative potential of the world’s fastest blockchain.

SuperApp

Envision a single platform that combines numerous services — from instant messaging and social networking to decentralized finance (DeFi) and e-commerce. Powered by TON’s infinitely scalable blockchain, this SuperApp would serve as a comprehensive gateway to Web3, accommodating hundreds of millions of users and handling billions of transactions effortlessly within a familiar Telegram environment.

TON’s architecture is capable of supporting a full-fledged digital economy, providing a seamless experience comparable to popular Web2 applications, but with the advantages of decentralization, true digital ownership, and resistance to censorship.

Gaming

The gaming industry stands to gain immensely from TON’s rapid processing capabilities, enabling the creation of in-game economies that rival real-world systems. Thanks to TON’s architecture, game developers can deploy customized workchains with minimal or no fees, offering players smooth gameplay without overburdening other workchains.

TON’s technology allows for the development of more intricate game designs and economic models, potentially transforming the gaming experience.

Payment Infrastructure

TON facilitates rapid and cost-effective global financial transactions for individuals and businesses alike. This could revolutionize areas such as remittances, payroll, and e-commerce by ensuring transactions are completed swiftly and at minimal cost compared to traditional financial systems.

TON’s speed and scalability can enhance financial inclusivity by enabling microtransactions for the unbanked, thereby broadening access to the digital economy.

Decentralized Exchanges (DEXs) & DeFi

TON’s high transaction speed could usher in a new era for decentralized trading. High-frequency trading, which is mostly confined to centralized exchanges due to technical limitations, can now thrive in a decentralized setting.

This advancement can reduce slippage and maintain market stability, creating a fairer trading environment accessible to everyone.

Supply Chain Management

Developers can utilize TON’s infrastructure to build transparent and efficient supply chains. Real-time tracking and immediate transaction settlements enabled by TON can cut operational costs, prevent fraud, and verify product authenticity.

This application is particularly valuable for industries with complex logistics, such as pharmaceuticals, where tracking goods is crucial.

IoT Networks

The Internet of Things (IoT) involves billions of devices communicating and transacting autonomously. TON’s exceptional transaction speed makes it ideal for managing these networks, ensuring smooth and reliable machine-to-machine interactions.

This capability could lead to smarter cities, more responsive energy grids, and enhanced interactions between digital and physical realms.

TON’s remarkable transaction speed represents more than just a technical feat; it signifies a step towards a future where blockchain technology becomes integral to our everyday digital interactions.

The use cases discussed are just the beginning of TON’s potential, with many more possibilities yet to be discovered.

With its commitment to innovation and community, TON is well-positioned to lead the adoption of blockchain technology. The potential for TON to unify blockchains and Web2 into a cohesive decentralized ecosystem is now more tangible than ever.

In summary, TON is at the forefront of blockchain advancement, breaking new ground and setting high standards. Its ability to process transactions at unparalleled speeds paves the way for blockchain technology to become a fundamental component of global digital infrastructure. As we build on this success, we look forward to the TON Community exploring new ways TON will shape the future of the digital world.

While Toncoin (TON) is frequently highlighted as the primary token of The Open Network, there are numerous other tokens and coins within the ecosystem.

The Open Network isn’t just about promoting digital ownership or integrating blockchain with Telegram; it also focuses on real-world Web3 applications. A significant aspect is Decentralized Finance (DeFi), which relies on creating various fungible and non-fungible tokens (Jettons and Collectibles) on the blockchain.

TON provides an optimal environment for developing and utilizing all types of digital tokens, giving users full control and enabling them to maximize their value within the ecosystem.

Jettons

The TON Jetton standard, established in March 2022, allows developers to create unique cryptocurrencies called ‘Jettons’ on the TON Blockchain. Just as Ethereum hosts various tokens like SHIBA, USDT, and USDC alongside its native ETH, the TON Blockchain, with Toncoin (TON) as its primary asset, supports a range of distinctive jettons such as PUNK, BOLT, and STON.

Jettons on TON serve various purposes beyond being mere transactional instruments or monetary assets, including:

• Ecosystem Enhancement: Jettons play a crucial role in building micro-ecosystems around different products within the TON Ecosystem, nurturing more cohesive and engaged communities focused on shared interests.
• User Engagement: They encourage user participation in projects by rewarding involvement and contribution to the TON community.
• Rights Representation: Jettons can symbolize more than just monetary value; they may represent access rights to specific services or shares in projects. For instance, PUNK allows participation in exclusive tournaments within TON Punks, while STON provides access to unique digital Collectibles.

The TON App offers a comprehensive overview for those interested in exploring jettons, including details on trading volumes, price changes, and distribution. The TON Ecosystem anticipates a surge in new Jettons, especially in areas like NFT gaming and TON-based services.

Tokenova’s launch, a no-code Jetton self-launch platform on TON, simplifies this expansion.

Buying Jettons

Acquiring Jettons is straightforward and quick. You can purchase them directly within Telegram via TON Space using Wallet in Telegram or through exchanges like STON.fi or DeDust.

Storing Jettons

Storing TON Jettons has become more user-friendly; they can now be saved directly in major TON wallets such as Tonkeeper and TON Space in Telegram, making it more convenient compared to platforms like MetaMask.

Collectibles

In contrast to Jettons, which are fungible, Collectibles are unique or ‘non-fungible’ digital assets. These assets can include digital art or rare items, each with distinct features and value. Collectibles grant users complete ownership over the items they represent. For example, Telegram usernames and virtual phone numbers on Fragment are unique digital Collectibles.

Collectibles within the TON Ecosystem offer a range of functionalities, including:

• Trading Potential: Collectibles serve as tradeable digital assets, allowing users to buy, sell, and exchange them within the TON Ecosystem.
• Exclusive Access: They can provide special privileges such as access to exclusive events or ticketing.
• Gaming Integration: Collectibles can be used in GameFi, enabling players to engage with blockchain-based games on TON.

TON supports advanced NFT standards beyond traditional Collectibles, including the Soulbound Token (SBT) and the Compressed NFT (cNFT). SBTs are non-transferable tokens suited for social permissions or certifications, like marketplace discounts or educational credentials.

The cNFT standard, featured in Egg Fight Club on Getgems, facilitates the creation of large NFT collections, accommodating up to a billion elements, making it ideal for gaming competitions.

Conclusion

Tokens, both fungible and non-fungible, are integral to the TON Ecosystem. TON’s user-friendly interfaces for acquiring and storing digital assets, along with its diverse marketplace options, reflect its mission to democratize digital ownership and integrate crypto into everyday use.

As the network continues to grow and evolve, the potential and utility of these tokens are expected to expand, offering exciting opportunities for both users and developers.

In recent weeks, The Open Network (TON) has witnessed a revolutionary development with the introduction of inscriptions. Since the debut of the first inscriptions protocol on TON, there have been 83 million transactions, 105,000 new unique users, and 2,525 new inscription tokens launched. Additionally, TON has generated over 170,000 TON in transaction fees.

Prior to the launch of inscriptions, TON averaged around 50,000 daily transactions, with a total transaction count of 198 million. Since December 5, activity has surged to an average of 1.5 million daily transactions, pushing the total to 274 million—an almost 40% increase in just 15 days.

This surge appears to be just the start, as more inscription protocols are expected to launch on TON soon. With Tonano and ShardZone already in place, and Gram20 currently launching, the momentum continues to build.

What Are Inscriptions?

Inscriptions began on the Bitcoin blockchain with the Ordinals protocol, created by software engineer Casey Rodarmor. This protocol was designed to embed data directly onto individual satoshis—the smallest unit of Bitcoin—allowing for the creation of unique digital assets within the Bitcoin blockchain, which was not originally intended for such functionality.

In recent months, the concept of BRC-20 tokens, initially a workaround for Bitcoin’s lack of native token support, has expanded to other blockchains. These tokens, adapted to fit various blockchain platforms, now appear under different names such as PRC-20 on Polygon PoS, Ethscriptions on Ethereum, Doginals on Dogecoin, and Solana Inscriptions on Solana. This expansion has significantly increased network activity across all participating blockchains, and now, they have arrived on TON, where no official standard has yet been established.

Challenges with Inscriptions

The rise in blockchain activity due to inscriptions has posed challenges for many networks, especially Bitcoin, where there is debate among core developers about whether this development should be considered spam or an innovative advancement.

For blockchains like Bitcoin, Ethereum, and Avalanche, increased demand from inscriptions has led to higher transaction fees and, at times, has made the networks nearly unusable. Other chains, such as TON, Arbitrum, and ZkSync, initially struggled with the increased transaction load, resulting in issues like network congestion and temporary halts.

TON also faced growing pains, with validators needing to manage the sudden surge in transaction volumes. However, the TON Core Development Team acted promptly, collaborating with validators worldwide to address the congestion and keep the network running smoothly.

Why Are Inscriptions Gaining Popularity?

Despite these challenges, inscriptions are gaining traction for several reasons:

• Innovation: Inscriptions introduce a novel approach to blockchain technology, offering a unique method for creating and managing tokens.
• Cost Efficiency: Tokens created through inscriptions generally incur lower transaction costs compared to those built on smart contracts on other blockchains.
• Accessibility: The process of creating inscriptions is more accessible, resembling the simplicity of proof-of-work mining.
• Speculation: As with many cryptocurrency trends, inscriptions attract investors due to the potential for rapid value appreciation.

Why Are Inscriptions Coming to TON?

Inscriptions have demonstrated their potential across various major blockchains, but their success depends on finding a high-performance blockchain to handle the associated issues of transaction fees and network congestion.

TON is well-suited to this role for several reasons:

• High Performance: TON can achieve speeds of up to 104,715 transactions per second, as demonstrated in a recent record attempt. Although this test was conducted on a testnet to prevent disruptions, it showcased TON’s scalability. The network recently reached its 200 millionth transaction and is projected to hit 300 million within 30 days.
• Stable Fees: TON maintains a fixed fee structure, keeping transaction costs low even during peak loads. Since the launch of inscriptions, the average fee has been just $0.004 per transaction.
• Telegram Integration: TON’s integration with Telegram offers a unique distribution channel, enabling the 800 million Telegram users to easily access a TON wallet and perform transactions directly within the app. This feature enhances user experience and project reach.

Use Cases for Inscriptions

Inscriptions, being unique tokens, share similar use cases with traditional tokens based on smart contracts. Major use cases include:

• Fair Token Launch: Unlike regular smart contract tokens, inscriptions are minted by users, who only pay for transaction fees. This method ensures fair distribution as no user has an advantage, potentially setting a new standard for initial token launches.
• Collectibles and NFTs: Inscriptions can function as NFTs, allowing unique data such as images or text to be attached to individual cryptocurrency units. This capability offers a new avenue for digital art and media to be stored, authenticated, and traded.

In summary, inscriptions on TON represent a significant evolution in digital tokens. While they present some challenges, their potential for innovation, cost efficiency, and unique use cases make them a noteworthy development in the blockchain space. As the TON Ecosystem continues to grow, the impact of inscriptions will likely become even more pronounced.

In our latest overview of the TON Ecosystem, we spotlighted several key uses for Toncoin, including staking as a major feature. As of March 6, 2024, the ecosystem boasts 424,382,249 Toncoin staked, with a total value exceeding $1 billion. This article will guide TON holders through the staking process, illustrating its role in network security and liquidity enhancement.

TON’s ecosystem projects across DeFi, SocialFi, and GameFi are positioned for significant success, thanks to the blockchain’s direct access to Telegram’s extensive user base of about 800 million monthly active users. With unparalleled scalability and shardability, TON provides a competitive edge to any project within its network.

A core promise of cryptocurrency has been to transform traditional banking systems. A fundamental service of traditional finance is the secure and efficient storage of assets, a concept now reimagined for Web3 through TON staking.

What is Staking on TON?

TON Blockchain utilizes a Proof-of-Stake (PoS) consensus mechanism to ensure network security and consensus. This model is more energy-efficient compared to Bitcoin’s Proof-of-Work (PoW) system. Unlike PoW, which relies on miners solving complex algorithms, PoS selects validators based on the amount of cryptocurrency they lock up as collateral.

In essence, the more cryptocurrency you stake, the higher your chances of being chosen as a validator. This system incentivizes validators to act in the network’s best interest, as their investment aligns with maintaining network integrity. For a detailed guide, refer to the full documentation here.

To add a transaction to the TON Blockchain, it must receive unanimous approval from all validators. Users pay a small transaction fee, which compensates the validators for their role in achieving consensus. This fee, along with any new coins minted during the validation process, is distributed among validators based on their stake and contributions.

Anyone interested in securing the network can become a validator, though typically a minimum stake of 600,000 TON is required. To make participation more accessible, TON offers staking services that allow average holders to pool their resources and earn rewards collectively. This makes network security open to everyone.

Pooling is usually facilitated by independent smart contracts and DAOs, which manage deposits and distribute rewards. Within the TON Ecosystem, several reputable projects provide these services, offering a secure and efficient staking experience.

Ton Whales

Ton Whales was the pioneer in offering decentralized staking on the TON Blockchain, attracting over 9,000 users who have collectively staked approximately $62 million. They have distributed around 1,132,103 TON in rewards to their users. Ton Whales maintains transparency by keeping their smart contract and DAO open-source, allowing users to verify operations themselves. The platform ensures smooth operations with continuous monitoring.

Ton Whales provides various staking pools with different requirements and conditions, boasting annual percentage yields (APY) from approximately 4.05% to 5.85%. They have integrated their staking services within several TON wallets, including Tonkeeper, for user convenience.

Tonstakers

Tonstakers offers a liquid staking protocol that allows users to stake their TON while still utilizing their assets within the TON Ecosystem. By staking with Tonstakers, users receive tsTON tokens, which represent their share in the staking pool and can be used across DeFi applications. Users can exchange tsTON back to Toncoin, along with accumulated yield, at their discretion.

As of March 6, 2024, Tonstakers has over 23,000 participants and $69.7 million staked, with an APY of up to 5% for the year ending December 31, 2023. Developed in collaboration with TON core developers, the platform features open-source contracts and has been audited by Certik. Tonstakers operates on a non-custodial basis, ensuring users retain control of their assets. Their services are available through a Telegram Mini App and integrated within TON wallets like Tonkeeper.

bemo

bemo is another liquid staking service featuring a Telegram Mini App. By staking with bemo, users earn stXP (Staking Experience Points), which will convert to $BMO tokens in Q4 2024. Up to 20% of $BMO tokens will be distributed to stXP holders, with higher balances receiving more tokens.

bemo offers a flexible staking experience, allowing users to earn stXP and manage their stakes through the Telegram Mini App. The platform has been audited by Certik and TonTech, and reports an APY of 4.02% for 2023.

Hipo

Hipo offers a decentralized liquid staking solution, providing daily rewards from the start of staking. Participants receive hTON tokens, representing their staked TON, which can be used across the DeFi ecosystem. Hipo aims to maximize rewards through efficient deployment of staked TON and offers an easy unstaking process. Currently, nearly 1 million Toncoin is staked on Hipo. The platform has undergone audits by TonTech and Daniil Sedov.

Embrace the Future with TON Staking

TON staking presents an exciting opportunity for users to engage in the decentralized digital economy. With various staking options, including traditional and liquid staking, TON enables users to earn cryptocurrency passively with flexibility and security. Through advanced smart contracts and DAOs, TON is fostering a more inclusive and efficient financial system, demonstrating how blockchain technology can democratize access to financial investments and rewards.

Disclaimer: References to products or services in this blog do not imply endorsement. Cryptocurrency markets are volatile, and staking protocols may not always meet expectations. Readers should conduct their own research and seek professional advice. We are not liable for financial decisions or losses incurred.

For those familiar with the TON blockchain, it’s widely recognized that TON can be mined. However, TON has never operated on a Proof-of-Work (PoW) consensus. Instead, it uses a Proof-of-Stake (PoS) consensus algorithm with sharding capabilities, which offers tightly integrated sharding, a feature PoW lacks.

The TON blockchain is fundamentally a PoS system, where validators play a crucial role. There are currently over 100 validators globally, most of them private. TON holders can stake their tokens with validators, earning about 13% annually through PoS staking rewards.

For example, on platforms like TonStake.com, users can stake their TON tokens to validators and potentially earn 13% extra TON in a year as a reward. The TON blockchain’s PoS infrastructure includes various roles such as Validators, Fisherman, Nominator, and Collator, all working together to maintain the network’s integrity.

Validators

Validators are tasked with verifying unconfirmed transactions and adding them to the blockchain, completing the process of transaction validation. When validators perform their roles correctly, they earn a reward. This reward comes from the TON blockchain’s annual growth rate, currently set at 0.6%. For instance, if the total supply is 5,000,000,000 TON, validators would receive 30,000,000 TON over the year as a reward for their contributions, distributed in line with this growth rate.

To become a validator on the TON blockchain, you go through four key stages:

• Elections: This lasts seven hours. You must send TON to a special elections smart contract to participate. Note that regular transactions won’t work and could lead to loss of TON.
• Threshold Confirmation: This takes two hours to check if your stake meets the minimum requirement to become a validator. If it doesn’t, your TON is returned.
• Validation Session: This stage lasts up to 18 hours, during which your system validates transactions. Strict hardware requirements are recommended, as any issues could lead to fines.
• Stakeholding: After the validation session, your TON is locked for up to nine hours, after which you can withdraw your funds.

The figure below represents a PoS operation state diagram of the TON blockchain, where it’s evident that two working states overlap. Currently, there are over 180 validator services worldwide, which enhances the decentralization of the TON blockchain.

However, several issues arise for users who wish to become validators and earn rewards. First, they need to have a high-performance computer with at least 16 cores, 64GB of RAM, a 512GB SSD, and a 1 Gbit/s internet connection, which entails substantial equipment costs for regular users.

Second, beyond purchasing the necessary hardware, users must also ensure the stability of power, network, hardware, and operating systems. Any failure in the host can lead to asset loss and harm the TON blockchain network.

Third, since a validator is a public service connected to the global network, it will be exposed to potential global hacker attacks. In the near future, your validator could become a target for hackers, potentially resulting in its paralysis or the theft of all your TON.

Fourth, in addition to acquiring hardware, maintaining stability, and ensuring security, there is also a significant financial threshold required to become a validator. While the official requirement is 10,000 TON to participate in the election, this amount is not sufficient to be elected as a validator. Investing only 10,000 TON will not yield any PoS rewards. As described in the operational principles above, the PoS operation is divided into two rounds, and to have a chance of being elected in either round, you need to invest 300,000 TON. To fully participate as a validator, more than 600,000 TON is required, which is almost unattainable for regular users.

Tonstake.com and Ton Whales are the two most prominent staking service providers. The main difference between them is how they manage TON’s cash flow.

Tonstake.com operates as a custodial staking service, functioning similarly to major cryptocurrency exchanges. Users deposit their funds to a specified address, and the system automatically allocates these funds across various validator nodes. When it comes time to withdraw, the funds are first routed through a withdrawal address before reaching the user. The benefit of using a custodial staking provider lies in the additional services offered, such as enterprise-level API support, detailed reporting, private node options, and lower barriers to entry. However, the security challenges are akin to those faced in conventional information security. Tonstake.com imposes a 10% fee on the interest earned by users as a service charge.

Ton Whales offers a non-custodial staking service where deposits and withdrawals are fully automated through smart contracts. This system makes sure that funds are automatically directed to validators. However, there is a risk that there might be some bugs in these smart contracts, especially in the newer versions. By using smart contracts, Ton Whales can cut the costs of running and maintaining the system a lot. The platform is currently stable and takes a 25% fee from the interest users earn. Ton Whales is still the biggest staking service provider on the market.

The two structures mentioned above are designed to give TON holders the opportunity to participate in staking services. A more comprehensive Nominator role is detailed in the original TON blockchain white paper.

Key features of the Nominator include:

• It functions as a smart contract.
• It serves as an investment smart contract, allowing TON holders to escrow their funds with the Nominator.
• It evaluates validators based on their performance and health.
• It allocates funds to validators according to their health scores.
• It participates in voting on the TON blockchain.
• The Nominator earns a portion of the commission.

I believe that the Nominator will evolve into the primary mechanism for staking services in the future. The current platforms like Tonstake.com and Ton Whales are merely transitional products during this period of change.