It's "inputs" and "outputs" of an operation. The part before - is what needs to be on the top of the stack to be used. The part after - is what's placed on the top of the stack after it's over. The letters stand for data types (Builder is noted as b, and so on).

So in this particular case this notation means that the operation requires an instance of Builder data type to be on the top of the stack, it takes that Builder instance and returns a number (of bits already stored in that Bu...

TON strives to be a decentralized system, as most blockchains do. That means that instead of relying on some "single superpower" it's better to have an "array of equal powers". And that means it wouldn't be good for the system if there emerged some "dominating super-validator" with an insane sum as its stake. It's better to have many separate validators with smaller sums.

That's why the system is tuned in such a way it encourages people to create more validators instead of putting all thei...

Your understanding is close to the truth.

As far as I understand, "atomicity" in this context is a concept that was born way before the TON blockchain. It has probably emerged in the database field: https://en.wikipedia.org/wiki/Atomicity_(database_systems)

It uses the atom metaphor as something that can't be divided (even though humanity managed to split the atom after all). So the "atomic event" is an "undivisible" event. It may consist of several parts, but they act as a whole, they...

It's pretty simple using ton.js or TonWeb library, the instructions for both can be found in this tutorial: https://ton-community.github.io/tutorials/01-wallet/

There's a verifier.ton.org service for that.

"What things change" — well, lots of them. Different programming languages, different architecture that leads to different approaches, and so on. So be ready to re-learn many things.

There's an article specifically aimed at the Solidity developers, probably it's a good idea to start with that: https://blog.ton.org/six-unique-aspects-of-ton-blockchain-that-will-surprise-solidity-developers

And after that... just go through the basic TON stuff, I guess — documentation, tutorials and so on.

To put it simply:

All the blockchains, including TON, group new transactions into a "block" before they are added to the chain-like structure that consists of all the previous blocks (hence the word "blockchain"). And it always takes some noticeable time to create a new block, due to a number of factors.

But a block can contain lots of transactions. And that means the time it took to create a block was not spent on a single transaction, but on all of them at once.

So there is no cont...

Masterchain is a "system-level" chain for stuff that affects the whole network, and workchain is where the "regular life" happens such as users sending each other Toncoins. There is only one workchain at the moment, but there could be possibly much more in the future.

You could probably think of the masterchain as the "basement" of a building and of workchain(s) as the "floor(s)" where people actually live.

So mostly you don't need to deal with the "basement", you just do your stuff us...

There wasn't any until recently, but just this week Tonkeeper became the first TON wallet that has a Firefox version: https://addons.mozilla.org/en-US/firefox/addon/tonkeeper/

The ton-crypto JS library has a mnemonicNew function, I guess that's what you're looking for: https://github.com/tonwhales/ton-crypto

I haven't heard of such a tool, but it seems that for a developer it should be easy to create one. Libraries like ton-core let anyone programmatically get an address for any specific key/wallet contract combo, they don't even require internet for that. So a program that asks for a key and prints out the addresses of all the wallet contracts with that key would be just dozens lines of code.

This manual has the information needed to write it: https://ton-community.github.io/tutorials/01-w...

Address is derived from the initial state (initial code + initial storage) of the contract. So changing the code with set_code() should have no effect on the address, since the modified code won't be "initial".

Regarding the project ideas, there's TON Footsteps initiative with some ideas and bounties set for them: https://github.com/ton-society/ton-footsteps

Also it's usually a good idea to make projects that "scratch your own itch". Do you feel a need for something in the TON ecosystem? If you do, that might me a great starting point.

Regarding the jobs, there's a Careers page on https://jobs.ton.org/

Probably not all the companies use it, so you might also check out projects on ton.app a...

Since FunC does not have floating-point numbers, it can't use the first approach. But it provides ways to use several of the rest:

• The default / operator uses floor rounding
• The ~/operator uses mathematical rounding
• The ^/ operator uses ceiling rounding

Yes, there are such Jettons, for example, jUSDT (USDT transferred from Ethereum via bridge.ton.org) has the decimal precision set to 6: https://tonscan.org/jetton/EQBynBO23ywHy_CgarY9NK9FTz0yDsG82PtcbSTQgGoXwiuA

But it's also easy to create such a Jetton yourself using https://minter.ton.org. One just has to specify the decimal precision in the corresponding field on the website. By default it is set to 9, and it seems most people just don't change that number.

FunC exists since the very beginning of TON, and Tact 1.0 was released in March 2023 (less than two month ago), so it's just very new at the moment, and it's natural there are not many tutorials yet.

Speaking of the limitations: currently Tact is still undergoing reviews and security audits, so if you are developing something that holds a lot of money, for the time being it might be better to use FunC (or to use Tact and then audit the FunC code that Tact compiles to).

But for the lear...

There's a list of standard TVM exit code in the official documentation: https://docs.ton.org/learn/tvm-instructions/tvm-exit-code

Here it is:

0 - Standard successful execution exit code.
1 - Alternative successful execution exit code.
2 - Stack underflow. Last op-code consumed more elements than there are on the stacks. 1
3 - Stack overflow. More values have been stored on a stack than allowed by this version of TVM.
4 - Integer overflow. Integer does not fit into −2256 ≤ x < 2256 o...

There are two projects I know of:

• Pytonlib: https://github.com/psylopunk/pytonlib
• Rift: https://github.com/sky-ring/rift

I'm not an active user of them, so I can't recommend any one based on my personal experience, but from what I see, at the moment of writing Rift is more actively developed.

Andrey's project is called "Kotlin/Multiplatform SDK for The Open Network" and it's available on GitHub: https://github.com/andreypfau/ton-kotlin

It's the only project for working with TON using Kotlin I've heard of.

While AI chatbots might be helpful in some situations, it's important to understand their limitations.

One such limitation is that ChatGPT was trained on information up to 2021 and its knowledge of the world after that is very limited. TON is evolving rapidly and lots of things happened after 2021. There's indeed a project that had been previously called FreeTON, but it has been renamed to Everscale and parted ways with TON. So the answers you get seem outdated.

There's also a more fu...

At the time of writing, for all the versions that came out in 2023 there are release notes on GitHub: https://github.com/ton-blockchain/ton/releases

Unfortunately, it's not the case for most of the versions released in 2022.

The Fift section in the docs just got the Overview page for that.

Currently it lists such links:

• The whitepaper you mentioned
• «Introduction to Fift» blog post
• Fift script examples
• Video series in Russian (an [English...