TON

https://docs.ton.org/v3/documentation/
Admin
TON is a decentralized blockchain platform designed for fast transactions, secure smart contracts,...
Tokens:377,657
Snippets:1,881
Trust Score:10
Update:1 year ago
Show doc for...
Tokens:
Raw
### Getting Started with Tolk

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/overview

Steps to set up and begin developing with Tolk, including environment setup and building a basic counter contract.

```bash
npm create ton@latest
```

--------------------------------

### Create New TON Project

Source: https://docs.ton.org/v3/documentation/smart-contracts/getting-started/javascript

Command to create a new TON smart contract project using npm. This command initiates an interactive setup process to guide you through project creation.

```bash
npm create ton@latest
```

--------------------------------

### Tolk Smart Contract Development

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/overview

Guides and resources for developing smart contracts using the Tolk language on TON. Includes environment setup, language specifics, and comparisons with FunC.

```APIDOC
Tolk Smart Contract Development:

Overview:
  - Provides a high-level understanding of the Tolk language for TON smart contracts.

Environment Setup:
  - Instructions on how to set up the development environment for Tolk.

Simple Counter Contract:
  - A practical example demonstrating the creation of a basic counter smart contract using Tolk.

Language Guide:
  - Detailed explanation of Tolk's syntax, features, and best practices.

Tolk vs FunC Comparison:
  - In Short: A concise comparison of Tolk and FunC.
  - In Detail: An in-depth analysis of the differences between Tolk and FunC.
  - Mutability: Specifics on mutability in Tolk and FunC.
  - Standard Library: Comparison of standard library features.
  - Auto Packing to/from Cells: How Tolk handles automatic packing and unpacking of data into cells.
  - Universal createMessage: Usage of the createMessage function in Tolk.
  - The Magic Lazy: Explanation of lazy loading mechanisms in Tolk.

Changelog:
  - History and updates related to the Tolk language.
```

--------------------------------

### TON Smart Contracts IDE Plugins Overview

Source: https://docs.ton.org/v3/documentation/smart-contracts/getting-started/ide-plugins

This section provides an overview of IDE plugins for TON smart contract development. It covers general getting started information and links to specific language documentation.

```APIDOC
IDE Plugins:
  Overview: Information on setting up and using IDE plugins for TON smart contract development.
  Getting Started: Guides for integrating IDE plugins into your development workflow.
  Languages:
    Tact: Documentation for the Tact programming language for TON smart contracts.
    Tolk: Documentation for the Tolk programming language for TON smart contracts.
    FunC: Documentation for the FunC programming language for TON smart contracts.
    Fift: Documentation for the Fift programming language for TON smart contracts.
  Related Concepts:
    Addresses: How TON addresses are handled in smart contracts.
    Transaction Fees: Information on transaction costs and management.
    Sharding: Explanation of sharding mechanisms in TON.
    Message Management: Details on handling messages within smart contracts.
    TON Blockchain Limits: Understanding the limitations of the TON blockchain.
    Blueprint: Information on the Blueprint development framework.
```

--------------------------------

### TON Guidelines and Integration

Source: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/governance

Guidelines for getting started with TON, developing DApps, integrating with TON, and managing nodes.

```APIDOC
TON Guidelines:
  Quick Start: https://docs.ton.org/v3/guidelines/quick-start/getting-started
  DApps Overview: https://docs.ton.org/v3/guidelines/dapps/overview
  Integrate with TON: https://docs.ton.org/v3/guidelines/ton-connect/overview
  Nodes Overview: https://docs.ton.org/v3/guidelines/nodes/overview
  Web3 Overview: https://docs.ton.org/v3/guidelines/web3/overview
```

--------------------------------

### Install MyTonCtrl

Source: https://docs.ton.org/v3/documentation/infra/nodes/mytonctrl/mytonctrl-overview

Download and execute the MyTonCtrl installation script. It can be run as a non-root user with sudo permissions or by switching to the root user.

```bash
wget https://raw.githubusercontent.com/ton-blockchain/mytonctrl/master/scripts/install.sh
sudobash install.sh
```

```bash
wget https://raw.githubusercontent.com/ton-blockchain/mytonctrl/master/scripts/install.sh
su root -c'bash install.sh'
```

--------------------------------

### MyTonCtrl Installer Commands

Source: https://docs.ton.org/v3/documentation/infra/nodes/mytonctrl/mytonctrl-overview

Commands related to the MyTonCtrl installer, including help, clearing, exiting, checking status, setting arguments, enabling, updating, and configuration management.

```APIDOC
APIDOC:
  help(): Display help information
  clear(): Clear the console
  exit(): Exit the installer
  status(): Check the current status
  set_node_argument(arg_name, arg_value): Set a node argument
  enable(): Enable a feature or component
  update(): Update the MyTonCtrl installation
  plsc(): Print LS proxy configuration
  clcf(): Clear configuration
  print_ls_proxy_config(): Print the LS proxy configuration
  create_ls_proxy_config_file(): Create an LS proxy configuration file
  drvcf(): Drive configuration
  setwebpass(password): Set the web interface password
```

--------------------------------

### Helix IDE Setup for Tact Language

Source: https://docs.ton.org/v3/documentation/smart-contracts/getting-started/ide-plugins

Instructions for setting up the Tact language support in the Helix IDE. This includes installing tree-sitter-tact for syntax highlighting and tact-language-server for editor intelligence.

```Shell
For latest syntax highlighting, setup [tree-sitter-tact](https://github.com/tact-lang/tree-sitter-tact#helix)
For editor intelligence, setup [tact-language-server](https://github.com/tact-lang/tact-language-server#other-editors)
```

--------------------------------

### Contribute Example Smart Contract

Source: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/examples

Instructions for community members to contribute new example smart contracts to the TON documentation. Contributions are made via pull requests to the specified GitHub repository.

```Markdown
If you want to share a new example smart contract, make your PR for this [page](https://github.com/ton-community/ton-docs/tree/main/docs/v3/documentation/smart-contracts/contracts-specs/examples.mdx).
```

--------------------------------

### TON Smart Contract Development with Blueprint

Source: https://docs.ton.org/v3/documentation/smart-contracts/getting-started/javascript

Blueprint is a development environment for TON that facilitates the writing, testing, and deployment of smart contracts. This section provides an overview of its capabilities and related smart contract development aspects.

```javascript
// Blueprint is a development environment for TON.
// It helps in writing, testing, and deploying smart contracts.
// For more details, refer to the official TON documentation.
```

--------------------------------

### @tegro/ton3-client Jettons Example

Source: https://docs.ton.org/v3/documentation/dapps/defi/tokens

An example demonstrating how to query information about Jettons using the @tegro/ton3-client SDK, providing insights into token balances and details.

```TypeScript
https://github.com/TegroTON/ton3-client#jettons-example
```

--------------------------------

### Install and Use mnemonic2key for Wallet Import

Source: https://docs.ton.org/v3/documentation/infra/nodes/mytonctrl/mytonctrl-overview

Steps to clone, install, and use the mnemonic2key tool to convert a mnemonic phrase into wallet files, which are then used to import the wallet into MyTonCtrl.

```bash
git clone https://github.com/ton-blockchain/mnemonic2key.git
cd mnemonic2key
npm install
```

```javascript
node index.js word1 word2 ... word24 [address]
```

--------------------------------

### Simple Counter Smart Contract Example

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/in-detail

A practical example demonstrating the development of a simple counter smart contract using the Tolk language.

```APIDOC
Simple Counter Contract Example (Tolk):

This example showcases a basic counter smart contract written in Tolk.

Features:
- **State**: Stores an integer counter value.
- **Functions**: Includes functions to increment the counter and retrieve its current value.
- **Deployment**: Demonstrates how to deploy and interact with the contract.

Code structure:
```tolk
// Contract definition
contract Counter {
    counter: int = 0;

    // Function to increment the counter
    increment() {
        self.counter += 1;
    }

    // Function to get the current counter value
    get_value(): int {
        return self.counter;
    }
}
```
```

--------------------------------

### Smart Contracts Documentation

Source: https://docs.ton.org/v3/documentation/smart-contracts/func/libraries

Covers various aspects of TON smart contracts, including addresses, getting started, specifications, limits, message management, transaction fees, sharding, and different programming languages like Tact, Tolk, and Fift.

```APIDOC
Smart Contracts:
  Introduction: https://docs.ton.org/v3/documentation/smart-contracts/overview
  Addresses: https://docs.ton.org/v3/documentation/smart-contracts/func/libraries
  Getting Started: https://docs.ton.org/v3/documentation/smart-contracts/func/libraries
  Contracts Specification: https://docs.ton.org/v3/documentation/smart-contracts/func/libraries
  TON Blockchain Limits: https://docs.ton.org/v3/documentation/smart-contracts/limits
  Message Management: https://docs.ton.org/v3/documentation/smart-contracts/func/libraries
  Transaction Fees: https://docs.ton.org/v3/documentation/smart-contracts/func/libraries
  Sharding: https://docs.ton.org/v3/documentation/smart-contracts/func/libraries
  Tact Language: https://docs.ton.org/v3/documentation/smart-contracts/tact
  Tolk Language: https://docs.ton.org/v3/documentation/smart-contracts/func/libraries
  FunC Language: https://docs.ton.org/v3/documentation/smart-contracts/func/libraries
  Fift Language: https://docs.ton.org/v3/documentation/smart-contracts/func/libraries
```

--------------------------------

### Tolk Language Guide

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/in-detail

A comprehensive guide to the Tolk smart contract language, covering its syntax, features, and best practices for developing TON smart contracts.

```APIDOC
Tolk Language Guide:

This guide provides a detailed explanation of the Tolk programming language used for developing smart contracts on the TON blockchain.

Content includes:
- **Syntax and Semantics**: Core language constructs, data types, and operators.
- **Control Flow**: Conditional statements, loops, and function calls.
- **State Management**: How to define and modify contract state.
- **Message Handling**: Sending and receiving messages between contracts.
- **Error Handling**: Strategies for managing errors and exceptions.
- **Best Practices**: Recommendations for writing efficient and secure Tolk code.
```

--------------------------------

### Tact Contribution Guide

Source: https://docs.ton.org/v3/documentation/smart-contracts/tact

Information on how to contribute to the development of the Tact compiler, with a link to the contributing guide.

```tact
Contributing:
  Contributions are welcome!
  See the contributing guide: https://github.com/tact-lang/tact/blob/main/dev-docs/CONTRIBUTING.md
```

--------------------------------

### Global Installation of Tact Compiler

Source: https://docs.ton.org/v3/documentation/smart-contracts/tact

Shows how to install the Tact compiler globally, making the 'tact' compiler, 'unboc' disassembler, and 'tact-fmt' formatter available on the system's PATH.

```bash
npm i -g @tact-lang/compiler
```

--------------------------------

### Install Pyth TON SDK with npm

Source: https://docs.ton.org/v3/documentation/dapps/oracles/pyth

Installs the Pyth TON SDK and related dependencies using npm for integration with TON smart contracts.

```bash
npm install @pythnetwork/pyth-ton-js @pythnetwork/hermes-client \
@ton/core @ton/ton @ton/crypto
```

--------------------------------

### Fift Smart Contract Examples

Source: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/examples

A comprehensive list of Fift smart contract examples for various functionalities on the TON blockchain. These include wallet implementations, DNS management, configuration proposals, and test giver scripts.

```fift
CreateState.fif
assembly-to-cpp.fif
auto-dns.fif
complaint-vote-req.fif
complaint-vote-signed.fif
config-proposal-vote-req.fif
config-proposal-vote-signed.fif
create-config-proposal.fif
create-config-upgrade-proposal.fif
create-elector-upgrade-proposal.fif
envelope-complaint.fif
gen-zerostate-test.fif
gen-zerostate.fif
highload-wallet-v2-one.fif
highload-wallet-v2.fif
highload-wallet.fif
manual-dns-manage.fif
new-auto-dns.fif
new-highload-wallet-v2.fif
new-highload-wallet.fif
new-manual-dns.fif
new-pinger.fif
new-pow-testgiver.fif
new-restricted-wallet.fif
new-restricted-wallet2.fif
new-restricted-wallet3.fif
new-testgiver.fif
new-wallet-v2.fif
new-wallet-v3.fif
new-wallet.fif
show-addr.fif
testgiver.fif
update-config-smc.fif
update-config.fif
update-elector-smc.fif
validator-elect-req.fif
validator-elect-signed.fif
wallet-v2.fif
wallet-v3.fif
wallet.fif
wallet-v3-code.fif
```

--------------------------------

### Blueprint Simple Contract Example

Source: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/examples

An example of a simple smart contract created using the Blueprint framework for TON development.

```FunC
;; Simple Blueprint contract

func init() {
    return {
        boc: "..."
    };
}

func receive(msg) {
    // ... contract logic ...
    return {
        boc: "..."
    };
}
```

--------------------------------

### Tolk Language Guide

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/language-guide

Provides a detailed guide to the Tolk programming language for TON smart contracts, covering its features, syntax, and usage.

```Tolk
This section details the Tolk language, a high-level language for TON smart contract development. It covers:
- Overview of Tolk
- Environment setup for Tolk development
- Examples like the simple counter contract
- Comparisons with FunC language, including differences in mutability, standard library, and specific features like createMessage and lazy loading.
- History and changelog of the Tolk language.
```

--------------------------------

### NFT Minter using Golang

Source: https://docs.ton.org/v3/documentation/dapps/defi/tokens

Golang library and examples for NFT minting, provided by tonutils-go. This resource includes comments and comprehensive examples for working with NFTs in Golang.

```Golang
// Golang code for NFT minting with comments and examples.
```

--------------------------------

### Install Pyth TON SDK with yarn

Source: https://docs.ton.org/v3/documentation/dapps/oracles/pyth

Installs the Pyth TON SDK and related dependencies using yarn for integration with TON smart contracts.

```bash
yarn add @pythnetwork/pyth-ton-js @pythnetwork/hermes-client \
@ton/core @ton/ton @ton/crypto
```

--------------------------------

### FunC Code Snippet Example

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/in-short

A basic example of FunC code demonstrating function declaration, variable assignment, and return values.

```FunC
global stored_v:int;

fun parse_data(cs:slice):cell {
  var flags:int = cs.load_int(32);
  return null();
}

fun sum(a:int, b:int):int {
  var both = a + b;
  return both;
}

get fun current_counter():int {
  return 0;
}
```

--------------------------------

### Verify TON Binaries Installation

Source: https://docs.ton.org/v3/documentation/archive/precompiled-binaries

Checks if the TON binaries (fift, func, lite-client) are installed and accessible by verifying their versions.

```bash
fift -V
func -V
lite-client -V
```

--------------------------------

### TON Proof Verification Examples

Source: https://docs.ton.org/v3/documentation/data-formats/tlb/proofs

Provides links to external code repositories demonstrating proof verification for TON blocks in Python, Kotlin, and C++. These examples showcase practical implementations of the verification logic.

```python
https://github.com/yungwine/pytoniq-core/blob/873a96aa2256db33b8f35fbe2ab8fe8cf8ae49c7/pytoniq_core/proof/check_proof.py#L19
```

```kotlin
https://github.com/andreypfau/ton-kotlin/blob/b1edc4b134e89ccf252149f27c85fd530377cebe/ton-kotlin-liteclient/src/commonMain/kotlin/CheckProofUtils.kt#L15
```

```cpp
https://github.com/ton-blockchain/ton/blob/24dc184a2ea67f9c47042b4104bbb4d82289fac1/crypto/block/check-proof.cpp#L34
```

--------------------------------

### Tolk Language Guide

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/changelog

Provides a detailed guide to the Tolk programming language for TON smart contracts, covering its features, syntax, and usage.

```Tolk
This section contains detailed information about the Tolk language, including its syntax, semantics, and examples of how to write smart contracts using Tolk. Refer to the official documentation for specific code examples and tutorials.
```

--------------------------------

### Basic Fift Execution Example

Source: https://docs.ton.org/v3/documentation/smart-contracts/fift/overview

A simple Fift code snippet demonstrating basic execution syntax. This example shows a string concatenation and execution pattern.

```fift
{."hello "  
execute."world"
helloworldok
}
```

--------------------------------

### Tolk Function Examples

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/language-guide

Provides examples of Tolk function declarations, including functions with specific parameter and return types like 'slice' and 'cell', and a 'main' function.

```Tolk
funparseData(cs:slice):cell{}
funloadStorage():(cell,int){}
funmain(){...}  
```

--------------------------------

### TON Smart Contract Examples

Source: https://docs.ton.org/v3/documentation/smart-contracts/func/overview

Provides links to various standard smart contracts on TON, such as wallets, validators, and multi-signature wallets. These examples serve as learning references for developers.

```APIDOC
Smart Contract Examples:
  Description: Links to standard smart contracts like wallets, validators, and multi-signature wallets.
  Purpose: Serves as learning references for developers.
  Link: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/examples/
```

--------------------------------

### TON Development Environment Setup

Source: https://docs.ton.org/v3/documentation/archive/precompiled-binaries

Instructions for setting up the TON development environment, including the 'func', 'fift', and 'lite client' binaries. This is for local development without Javascript.

```APIDOC
Setting up TON Development Environment:
  - Provides instructions for local development of TON smart contracts without Javascript.
  - Requires binaries for 'func', 'fift', and 'lite client'.
  - Refer to the TON Society article for detailed steps.
```

--------------------------------

### Neovim Tact Support

Source: https://docs.ton.org/v3/documentation/smart-contracts/getting-started/ide-plugins

To enable Tact syntax highlighting in Neovim, users should follow the nvim-treesitter quickstart guide and install the tact.vim plugin to ensure proper recognition of the .tact extension.

```APIDOC
Neovim Tact Support:
  Description: Enables Tact syntax highlighting and file extension recognition in Neovim.
  Installation Steps:
    1. Follow the nvim-treesitter quickstart guide for general setup: https://github.com/nvim-treesitter/nvim-treesitter#quickstart
    2. Install the tact.vim plugin: https://github.com/tact-lang/tact.vim
```

--------------------------------

### Tolk Smart Contract Language Guide

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/environment-setup

Provides a comprehensive guide to the Tolk smart contract language, covering its features, syntax, and usage within the TON ecosystem. This includes comparisons with FunC and details on mutability and standard library functions.

```Tolk
Overview: https://docs.ton.org/v3/documentation/smart-contracts/tolk/overview
Environment setup: https://docs.ton.org/v3/documentation/smart-contracts/tolk/environment-setup
Simple counter contract: https://docs.ton.org/v3/documentation/smart-contracts/tolk/counter-smart-contract
Language guide: https://docs.ton.org/v3/documentation/smart-contracts/tolk/language-guide
Tolk vs FunC: in short: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/in-short
Tolk vs FunC: in detail: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/in-detail
Tolk vs FunC: mutability: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/mutability
Tolk vs FunC: standard library: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/stdlib
Auto packing to/from cells: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/pack-to-from-cells
Universal createMessage: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/create-message
The magic lazy: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/lazy-loading
History of Tolk: https://docs.ton.org/v3/documentation/smart-contracts/tolk/changelog
```

--------------------------------

### TON Smart Contract Counter Example (Tolk)

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/counter-smart-contract

Provides an example of a simple counter smart contract written in the Tolk language. This snippet is part of a larger guide on Tolk smart contract development.

```Tolk
This section details the simple counter contract. The actual code is not provided in the input text, but its existence and purpose are described.
```

--------------------------------

### Tolk Environment Setup

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/in-detail

Instructions for setting up the development environment required for writing and deploying Tolk smart contracts.

```APIDOC
Tolk Environment Setup:

This guide outlines the necessary steps to configure your development environment for Tolk smart contracts.

Requirements:
- **TON SDK**: Installation and configuration of the TON Software Development Kit.
- **Tolk Compiler**: Obtaining and setting up the Tolk compiler.
- **Development Tools**: Recommended text editors or IDEs with Tolk support.
- **Testing Framework**: Setting up tools for testing smart contracts locally.
```

--------------------------------

### TON Wallet Get Methods

Source: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/wallet-contracts

Describes the available read-only methods for querying the state of a TON wallet contract, including sequence number, public key, subwallet ID, plugin installation status, and the list of installed plugins.

```APIDOC
Get Methods:
  1. seqno(): int - returns current stored seqno.
  2. get_public_key(): int - returns current stored public key.
  3. get_subwallet_id(): int - returns current subwallet ID.
  4. is_plugin_installed(int wc, int addr_hash): int - checks if plugin with defined workchain ID and address hash is installed.
  5. get_plugin_list(): tuple - returns list of plugins.
```

--------------------------------

### Create New TON Project with Blueprint

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/environment-setup

Initializes a new TON project using npm. It prompts the user for a project name and allows selection of a sample contract, such as a simple counter contract using Tolk.

```bash
npm create ton@latest
```

--------------------------------

### Highload Wallet Contracts Specification

Source: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/highload-wallet

Details the specification for highload wallet contracts in TON, covering addresses, getting started, and message management.

```APIDOC
Highload Wallet Contracts:
  Addresses: Information on wallet addresses.
  Getting Started: Guide to begin using highload wallets.
  Message Management: How to manage messages for highload wallets.
  Transaction Fees: Details on transaction fees associated with highload wallets.
  Sharding: Information on sharding relevant to highload wallets.
```

--------------------------------

### Invalid FunC Identifiers

Source: https://docs.ton.org/v3/documentation/smart-contracts/func/docs/literals_identifiers

Examples of identifiers that violate FunC's rules, such as containing prohibited special characters, starting with quotes, or being reserved keywords.

```FunC
take(first)Entry
"not_a_string
msg.sender
send_message,then_terminate
_
pa;;in"aaa""
{-aaa-}
aa(bb
123
```

--------------------------------

### Vim IDE Setup for TON Languages

Source: https://docs.ton.org/v3/documentation/smart-contracts/getting-started/ide-plugins

Instructions for setting up IDE plugins for TON smart contract languages in Vim.

```Shell
Vim
```

--------------------------------

### NFT Deployer in Python

Source: https://docs.ton.org/v3/documentation/dapps/defi/tokens

An NFT Deployer project implemented in Python. This example, developed by anomaly-guard, includes comments to guide users through the deployment process.

```Python
# Python script for NFT deployment with comments.
```

--------------------------------

### MyTonCtrl General Commands

Source: https://docs.ton.org/v3/documentation/infra/nodes/mytonctrl/mytonctrl-overview

Provides a list of general commands for interacting with MyTonCtrl, including help, exit, update, upgrade, status, installer, configuration retrieval, and mode management.

```APIDOC
MyTonCtrl General Commands:

help
  - Displays help information for MyTonCtrl commands.

exit
  - Exits the MyTonCtrl application.

update
  - Updates MyTonCtrl to the latest version.

upgrade
  - Upgrades the TON node software.

status
  - Displays the current status of the TON node.

installer
  - Manages the installation of TON node components.

status_modes
  - Shows available operational modes for the node.

status_settings
  - Displays the current configuration settings of the node.

enable_mode <mode_name>
  - Enables a specific operational mode.

disable_mode <mode_name>
  - Disables a specific operational mode.

about
  - Displays information about the MyTonCtrl version and the TON node.

get <parameter>
  - Retrieves the value of a specific node parameter.

set <parameter> <value>
  - Sets the value of a specific node parameter.

rollback <version>
  - Rolls back the TON node to a previous version.

getconfig
  - Retrieves the full node configuration.

get_pool_data
  - Fetches data related to the staking pool.
```

--------------------------------

### Neovim IDE Setup for TON Languages

Source: https://docs.ton.org/v3/documentation/smart-contracts/getting-started/ide-plugins

Instructions for setting up IDE plugins for TON smart contract languages in Neovim.

```Shell
Neovim
```

--------------------------------

### MyTonInstaller Console Commands

Source: https://docs.ton.org/v3/documentation/infra/nodes/mytonctrl/mytonctrl-overview

Basic commands for the MyTonInstaller console, including help, clearing the screen, exiting, and checking service status.

```bash
installer
help
clear
exit
status
```

--------------------------------

### TON Blockchain Period Calculation Example

Source: https://docs.ton.org/v3/documentation/network/configs/blockchain-configs

Illustrates how to calculate the start and end times for election and validation periods using the defined constants and an election ID. This helps in understanding the timing of validator roles and stake holding.

```python
election_id = 1600032768

election_start = election_id - constants['elections_start_before']
election_end = election_id - constants['elections_end_before']
hold_start = election_id + constants['validators_elected_for']
hold_end = hold_start + constants['stake_held_for']
```

--------------------------------

### Setup FIFTLIB for Fift (Windows)

Source: https://docs.ton.org/v3/documentation/archive/precompiled-binaries

Explains how to set up the FIFTLIB for the Fift compiler on Windows by creating the FIFTPATH environment variable.

```powershell
# Example: Assuming FIFTLIB is extracted to C:\Users\%USERNAME%\ton\lib\fiftlib
[System.Environment]::SetEnvironmentVariable('FIFTPATH', 'C:\Users\%USERNAME%\ton\lib\fiftlib', [System.EnvironmentVariableTarget]::User)
```

--------------------------------

### Tolk Dictionary Get with Non-Null Assertion

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/in-detail

Shows an example of using the '!' operator with a low-level dictionary API in Tolk. It illustrates how to handle the return type of `iDictGet` which returns `(slice?, bool)` and safely access the slice using the assertion.

```Tolk
@pure
fun dict.iDictGet(self, keyLen: int, key: int): (slice?, bool)
asm("keyselfkeyLen" DICTIGET NULLSWAPIFNOT)

var (cs, exists) = myDict.iDictGet(...);
// if exists is true, cs is not null
if (exists) {
  cs!.loadInt(32);
}
```

--------------------------------

### TON Smart Contract Getter Example

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/counter-smart-contract

Demonstrates a typical GET method (contract getter) in TON smart contracts. These methods execute off-chain and are used to read data from the contract's storage without consuming gas.

```ton-assembly
getfuncurrentCounter():int{
 valstorage=lazyStorage.load();
 returnstorage.counter;
}
```

--------------------------------

### Setup FIFTLIB for Fift (Linux/macOS)

Source: https://docs.ton.org/v3/documentation/archive/precompiled-binaries

Downloads, extracts, and sets up the FIFTLIB for the Fift compiler on Linux/macOS, including setting the FIFTPATH environment variable.

```bash
unzip fiftlib.zip
mkdir -p /usr/local/lib/fiftlib
cp fiftlib/* /usr/local/lib/fiftlib
# Set FIFTPATH environment variable (e.g., in ~/.bashrc or ~/.zshrc)
# export FIFTPATH=/usr/local/lib/fiftlib
```

--------------------------------

### Smart Contract Languages on TON

Source: https://docs.ton.org/v3/documentation/smart-contracts/getting-started/javascript

TON supports several programming languages for smart contract development, including Tact, Tolk, FunC, and Fift. Each language has its own syntax and use cases within the TON ecosystem.

```tact
// Tact is a high-level language for TON smart contracts.
// Example syntax and usage can be found in the TON documentation.
```

```tolk
// Tolk is another language for TON smart contracts.
// Refer to the TON documentation for its specific features and examples.
```

```func
// FunC is a low-level language for TON smart contracts, often used for performance-critical parts.
// Consult the TON documentation for FunC syntax and examples.
```

```fift
// Fift is a stack-based language used in TON, particularly for low-level operations and tooling.
// The TON documentation provides details on Fift usage.
```

--------------------------------

### MyTonCtrl General Commands

Source: https://docs.ton.org/v3/documentation/infra/nodes/mytonctrl/mytonctrl-overview

Provides an overview of common commands for interacting with the MyTonCtrl console, including help, exit, update, upgrade, status, installer, status_modes, status_settings, and enable_mode.

```APIDOC
help
  No args, prints help text.

exit
  No args, exits from the console.

update
  Updates MyTonCtrl.
  Format name | Format | Example | Description
  ---|---|---|---
  No args | `update` | `update` | Update from current repo
  URL format | `update [https://github.com/author/repo/tree/branch]` | `update https://github.com/ton-blockchain/mytonctrl/tree/test` | Update from specified URL
  Branch Only format | `update [BRANCH]` | `update test` | Update from specified branch of current repo
  Branch Override format | `update [https://github.com/authorName/repoName/tree/branchName] [BRANCH]` | `update https://github.com/ton-blockchain/mytonctrl/tree/master test` | Update the branch specified by the second argument in the designated repository

upgrade
  Updates the node.
  Format name | Format | Example | Description
  ---|---|---|---
  No args | `upgrade` | `upgrade` | Upgrade from current repo
  URL format | `upgrade [https://github.com/author/repo/tree/branch]` | `upgrade https://github.com/ton-blockchain/ton/tree/master` | Upgrade from specified URL
  Branch Only format | `upgrade [BRANCH]` | `upgrade master` | Upgrade from specified branch of current repo
  Branch Override format | `upgrade [https://github.com/authorName/repoName/tree/branchName] [BRANCH]` | `upgrade https://github.com/ton-blockchain/ton/tree/master testnet` | Upgrade from the branch specified by the second argument of the designated repository

status
  Gets current MyTonCtrl and node status.
  Format name | Format | Example | Description
  ---|---|---|---
  No args | `status` | `status` | Full status report including validator efficiency and online validators.
  Fast | `status fast` | `status fast` | This must be used on Testnet. The status report should exclude the efficiency of validators and the count of online validators.
  [See more about status output](https://docs.ton.org/v3/documentation/infra/nodes/mytonctrl/mytonctrl-status)

installer
  No args, runs the installer of TON modules (script `/usr/src/mytonctrl/mytoninstaller.py`).

status_modes
  No args, shows MTC modes.

status_settings
  No args, shows all available settings with their description and values.

enable_mode
  Enables a specific mode.
  MyTonCtrl> enable_mode <mode_name>
  Example:
  MyTonCtrl> enable_mode validator
```

--------------------------------

### VS Code Setup for FunC and Tact

Source: https://docs.ton.org/v3/documentation/smart-contracts/getting-started/ide-plugins

Instructions for setting up IDE plugins for FunC and Tact languages in VS Code to improve smart contract development workflow.

```Shell
FunC
Tact
```

--------------------------------

### Tolk GET Methods

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/language-guide

Shows the syntax for declaring 'GET' methods in Tolk, which are used for contract getters. These methods are prefixed with 'get fun'.

```Tolk
getfunseqno():int{
return1;
}  
```

--------------------------------

### Get Method Declaration

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/in-detail

Compares the declaration of 'get' methods, showing the shift from FunC's 'method_id' to Tolk's 'get fun' syntax.

```FunC
int seqno() method_id { ... }
```

```Tolk
get fun seqno(): int { ... }
```

```FunC
() after_code_upgrade(cont old_code) impure method_id(1666)
```

```Tolk
@method_id(1666)
fun afterCodeUpgrade(oldCode: continuation)
```

--------------------------------

### Smart Contracts Introduction and Guidelines

Source: https://docs.ton.org/v3/documentation/smart-contracts/fift/overview

Covers the introduction to smart contracts on TON, guidelines for development, addresses, contracts specification, message management, transaction fees, and sharding.

```Smart Contracts
https://docs.ton.org/v3/documentation/smart-contracts/overview
```

```Smart Contracts
https://docs.ton.org/v3/documentation/smart-contracts/fift/overview
```

```Smart Contracts
https://docs.ton.org/v3/documentation/smart-contracts/limits
```

--------------------------------

### NFT Minter Example in JavaScript

Source: https://docs.ton.org/v3/documentation/dapps/defi/tokens

A JavaScript example for an NFT Minter, part of the token-contract repository by TON Foundation. This example includes comments to explain the functionality.

```JavaScript
// Example NFT Minter code with comments.
```

--------------------------------

### IntelliJ IDE Setup for FunC and Tact

Source: https://docs.ton.org/v3/documentation/smart-contracts/getting-started/ide-plugins

Instructions for setting up IDE plugins for FunC and Tact languages in IntelliJ IDEs to enhance smart contract development.

```Shell
FunC
Tact
```

--------------------------------

### Project Initialization with Blueprint

Source: https://docs.ton.org/v3/documentation/smart-contracts/func/overview

Command to create a new TON project using the Blueprint framework, which simplifies smart contract development and compilation. This is a common starting point for developers.

```bash
npm create ton@latest
```

--------------------------------

### Offer List and Details Commands

Source: https://docs.ton.org/v3/documentation/infra/nodes/mytonctrl/mytonctrl-overview

Commands for viewing and analyzing offers, including options for different output formats and hash verbosity.

```APIDOC
MyTonCtrl> ol [arguments]

Description:
  Displays a list of offers. The output can be customized.
Arguments:
  (no arguments): Prints a table with shortened hashes.
  --json: Prints the offer list in JSON format.
  hash: Prints the table with full hashes.
  --json hash: Prints the JSON representation with full hashes.

MyTonCtrl> od [offer-hash]

Description:
  Retrieves and displays the differences (diff) for a specific offer.
Parameters:
  [offer-hash]: The hash of the offer to inspect. If omitted, it might default to the latest offer or prompt the user.
```

--------------------------------

### TON Smart Contract Examples

Source: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/highload-wallet

Provides examples of smart contracts for various use cases on the TON blockchain.

```APIDOC
Smart Contract Examples:
  Wallet Contracts: Examples of wallet contract implementations.
  Highload Wallet Contracts: Examples of highload wallet contract implementations.
  Vesting Contract: Examples of vesting contract implementations.
  Governance Contracts: Examples of governance contract implementations.
  Nominator Pool: Examples for nominator pool contracts.
  Single Nominator Pool: Examples for single nominator pool contracts.
  Precompiled Contracts: Examples of precompiled contracts.
```

--------------------------------

### Sublime Text Setup for FunC and Tact

Source: https://docs.ton.org/v3/documentation/smart-contracts/getting-started/ide-plugins

Instructions for setting up IDE plugins for FunC and Tact languages in Sublime Text for better smart contract development experience.

```Shell
FunC
Tact
```

--------------------------------

### Split Install Transaction Structure

Source: https://docs.ton.org/v3/documentation/data-formats/tlb/transaction-layout

Defines the structure for Split install transactions, used to deploy new instances of large smart contracts. This transaction type is currently unavailable. It includes fields for split information, the prepared transaction for the split, and an installation status.

```APIDOC
trans_split_install$0101split_info:SplitMergeInfo
prepare_transaction:^Transaction
installed:Bool=TransactionDescr;

Field | Type | Description
---|---|---
`split_info` | SplitMergeInfo | Information about the split process.
`prepare_transaction` | [Transaction](https://docs.ton.org/v3/documentation/data-formats/tlb/transaction-layout#transaction) | Information about the [transaction prepared](https://docs.ton.org/v3/documentation/data-formats/tlb/transaction-layout#split-prepare) for the split operation. Stored as a reference.
`installed` | Bool | Indicates whether the transaction was installed.
```

--------------------------------

### Blueprint Jetton Minter Contract

Source: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/examples

A smart contract example demonstrating how to mint Jettons on-chain using the Blueprint framework.

```FunC
;; Jetton minter contract

struct JettonData {
    total_supply: int;
    // ... other jetton data ...
}

func init(data: JettonData) {
    return {
        boc: "..."
    };
}

func mint(amount: int) {
    // ... minting logic ...
}
```

--------------------------------

### FunC Smart Contract Language

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/environment-setup

Documentation and resources for the FunC smart contract language used in TON. This includes comparisons with Tolk and details on specific language features.

```FunC
FunC language: https://docs.ton.org/v3/documentation/smart-contracts/tolk/environment-setup
```

--------------------------------

### TON Smart Contract Specifications and Examples

Source: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/examples

This section details the specifications and provides examples for various smart contracts on the TON blockchain. It covers different contract types such as wallets, highload wallets, vesting contracts, governance contracts, and more. It also links to resources for TON enhancement proposals (TEPs).

```APIDOC
Smart Contracts Specifications:
  Wallet contracts: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/wallet-contracts
  Highload wallet contracts: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/highload-wallet
  Vesting contract: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/vesting-contract
  Governance contracts: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/governance
  Nominator pool: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/nominator-pool
  Single nominator pool: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/single-nominator-pool
  Precompiled contracts: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/precompiled-contracts
  Examples of smart contracts: https://docs.ton.org/v3/documentation/smart-contracts/contracts-specs/examples
  TON enhancement proposals (TEPs): https://github.com/ton-blockchain/TEPs/tree/master
```

--------------------------------

### Deploy or Run Script with Blueprint

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/environment-setup

Deploys the compiled smart contract to a TON network (Mainnet, Testnet, or MyLocalTon) or runs custom deployment scripts. Supports both npm and yarn.

```bash
npx blueprint run
```

```bash
yarn blueprint run
```

--------------------------------

### TL-B Constructors with Hex Tags Example

Source: https://docs.ton.org/v3/documentation/data-formats/tlb/tl-b-language

Shows an example of TL-B constructors using hexadecimal tags and the corresponding pseudocode generation.

```TL-B
example_a#0=A;
example_b#1=A;
example_c#f=A;

class A:
    tags = [0, 1, 15]
    tags_names = ['example_a', 'example_b', 'example_c']
```

--------------------------------

### TL-B Hashmap Parsing Example

Source: https://docs.ton.org/v3/documentation/data-formats/tlb/tl-b-types

Provides a practical example of how to parse Hashmap TL-B types. This is useful for understanding data structures in TON.

```APIDOC
Hashmap Parsing Example:
  - Demonstrates the steps involved in parsing a Hashmap TL-B type, including key and value extraction.
```

--------------------------------

### Build TON Project with Blueprint

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/environment-setup

Compiles the smart contract code and generates bytecode. The output, including the bytecode and its hash, is saved in the `build/` directory. Supports both npm and yarn.

```bash
npx blueprint build
```

```bash
yarn blueprint build
```

--------------------------------

### Assembly Implementation Syntax

Source: https://docs.ton.org/v3/documentation/smart-contracts/tolk/tolk-vs-func/in-detail

Demonstrates the syntax for implementing assembly code, highlighting how Tolk aligns it for better readability.

```Tolk
@pure
fun third<X>(t:tuple):X
assembly "THIRD"

@pure
funiDictDeleteGet(dict:cell,keyLen:int,index:int):(cell,slice,int)
assembly(indexdictkeyLen) "DICTIDELGET NULLSWAPIFNOT"

@pure
funmulDivFloor(x:int,y:int,z:int):int
builtin
```

--------------------------------

### Serialized Create Channel Message Example

Source: https://docs.ton.org/v3/documentation/network/protocols/adnl/adnl-udp

An example of a serialized ADNL message for creating a channel, showing the TL ID, key, and date.

```tl
bbc373e6
d59d8e3991be20b54dde8b78b3af18b379a62fa30e64af361c75452f6af019d7
555c8763
```
Tokens:
Raw