Merge branch 'staging' into redirect-script

Author: a-bahdanau

docs/develop/network/overlay.md

@@ -1,5 +1,10 @@
 # Overlay subnetworks
 
+Implementation:
+* https://github.com/ton-blockchain/ton/tree/master/overlay
+
+## Overview
+
 The architecture of TON is built in such a way that a lot of chains can exist simultaneously and independently in it - they can be both private or public.
 Nodes have the ability to choose which shards and chains they store and process.
 At the same time, the communication protocol remains unchanged due to its universality. Protocols such as DHT, RLDP and Overlays allow this to be achieved.
@@ -11,6 +16,21 @@ All chains in TON, including the masterchain, communicate using their own overla
 To join it, you need to find the nodes that are already in it, and start exchanging data with them.
 For the public overlays you can find nodes using DHT.
 
+## ADNL vs Overlay networks
+
+In contrast to ADNL, the TON overlay networks usually do not support
+sending datagrams to other arbitrary nodes. Instead, some “semi-permanent
+links” are established between certain nodes (called “neighbors” with respect to
+the overlay network under consideration) and messages are usually forwarded
+along these links (i.e. from a node to one of its neighbors).
+
+Each overlay subnetwork has a 256-bit network identifier usually equal
+to a SHA256 of the description of the overlay network—a TL-serialized object.
+
+Overlay subnetworks can be public or private.
+
+Overlay subnetworks work according to a special [gossip](https://en.wikipedia.org/wiki/Gossip_protocol) protocol.
+
 ## Interaction with overlay nodes
 
 We have already analyzed an example with finding overlay nodes in an article about DHT,
@@ -70,4 +90,4 @@ Thus, we can receive information directly from the nodes.
 
 ## References
 
-_Here a [link to the original article](https://github.com/xssnick/ton-deep-doc/blob/master/Overlay-Network.md) by [Oleg Baranov](https://github.com/xssnick)._
+_Here a [link to the original article](https://github.com/xssnick/ton-deep-doc/blob/master/Overlay-Network.md) by [Oleg Baranov](https://github.com/xssnick)._

docs/develop/network/rldp.md

@@ -1,5 +1,12 @@
 # RLDP
 
+Implementation:
+* https://github.com/ton-blockchain/ton/tree/master/rldp
+* https://github.com/ton-blockchain/ton/tree/master/rldp2
+* https://github.com/ton-blockchain/ton/tree/master/rldp-http-proxy
+
+## Overview
+
 RLDP - Reliable Large Datagram Protocol - is a protocol that runs on top of ADNL UDP, which is used to transfer large data blocks and
 includes Forward Error Correction (FEC) algorithms as a replacement of acknowledgment packets on the other side. 
 This makes it possible to transfer data between network components more efficiently, but with more traffic consumption.
@@ -179,4 +186,4 @@ If `last` = true, then we have reached the end, we can put all the pieces togeth
 
 ## References
 
-_Here a [link to the original article](https://github.com/xssnick/ton-deep-doc/blob/master/RLDP.md) by [Oleg Baranov](https://github.com/xssnick)._
+_Here a [link to the original article](https://github.com/xssnick/ton-deep-doc/blob/master/RLDP.md) by [Oleg Baranov](https://github.com/xssnick)._

docs/develop/smart-contracts/tutorials/wallet.md

@@ -2105,7 +2105,7 @@ When working with many messages in a short period, there is a need for special w
 
 :::note
 We will work [with a slightly modified version of Wrapper](https://github.com/aSpite/highload-wallet-contract-v3/blob/main/wrappers/HighloadWalletV3.ts) for the contract, as it protects against some non-obvious mistakes.
-:::note
+:::
 
 
 ### Storage Structure

docs/learn/academy/academy-overview.md renamed to docs/learn/academy/academy-overview.mdx

@@ -19,3 +19,9 @@ The TON Project uses its own peer-to-peer network protocols.
 blockchain itself, thus providing more possibilities and flexibility for creating
   new services in the TON Ecosystem.
 
+## See Also
+
+* [ADNL Protocol](/learn/networking/adnl)
+* [Overlay Subnetworks](/learn/networking/overlay-subnetworks)
+* [RLDP Protocol](/learn/networking/rldp)
+* [TON DHT Service](/learn/networking/ton-dht)

docs/learn/networking/overlay-subnetworks.md

@@ -1,4 +1,4 @@
-# Smart Contract Addresses
+# Smart Contract Addresses Documentation
 
 This section will describe the specifics of smart contract addresses on TON Blockchain. It will also explain how actors are synonymous with smart contracts on TON.
 

docs/learn/networking/overview.md

@@ -1,6 +1,6 @@
 import Player from '@site/src/components/player'
 
-# Wallet Apps (for Devs)
+# Wallet Apps
 
 ## Overview
 

docs/learn/networking/rldp.md

@@ -101,64 +101,9 @@ Sometimes the functionality of basic wallets isn't enough. That's why there are
 
 Let's have a look at them.
 
-### Highload Wallet v3
+### Highload Wallets
 
-This wallet is made for who need to send transactions at very high rates. For example, crypto exchanges.
-
-- [Source code](https://github.com/ton-blockchain/highload-wallet-contract-v3)
-
-Any given external message (transfer request) to a highload v3 contains:
-- a signature (512 bits) in the top level cell - the other parameters are in the ref of that cell
-- subwallet ID (32 bits)
-- message to send as a ref (the serialized internal message that will be sent)
-- send mode for the message (8 bits)
-- composite query ID - 13 bits of "shift" and 10 bits of "bit number", however the 10 bits of bit number can only go up to 1022, not 1023, and also the last such usable query ID (8388605) is reserved for emergencies and should not be normally used
-- created at, or message timestamp
-- timeout
-
-Timeout is stored in highload as a parameter and is checked against the timeout in all requests - so the timeout for all requests is equal. The message should be not older than timeout at the time of arrival to the highload wallet, or in code it is required that `created_at > now() - timeout`. Query IDs are stored for the purposes of replay protection for at least timeout and possibly up to 2 * timeout, however one should not expect them to be stored for longer than timeout. Subwallet ID is checked against the one stored in the wallet. Inner ref's hash is checked along with the signature against the public key of the wallet.
-
-Highload v3 can only send 1 message from any given external message, however it can send that message to itself with a special op code, allowing one to set any action cell on that internal message invocation, effectively making it possible to send up to 254 messages per 1 external message (possibly more if another message is sent to highload wallet again among these 254).
-
-Highload v3 will always store the query ID (replay protection) once all the checks pass, however a message may not be sent due to some conditions, including but not limited to:
-- **containing state init** (such messages, if required, may be sent using the special op code to set the action cell after an internal message from highload wallet to itself)
-- not enough balance
-- invalid message structure (that includes external out messages - only internal messages may be sent straight from the external message)
-
-Highload v3 will never execute multiple externals containing the same `query_id` **and** `created_at` - by the time it forgets any given `query_id`, the `created_at` condition will prevent such a message from executing. This effectively makes `query_id` **and** `created_at` together the "primary key" of a transfer request for highload v3.
-
-When iterating (incrementing) query ID, it is cheaper (in terms of TON spent on fees) to iterate through bit number first, and then the shift, like when incrementing a regular number. After you've reached the last query ID (remember about the emergency query ID - see above), you can reset query ID to 0, but if highload's timeout period has not passed yet, then the replay protection dictionary will be full and you will have to wait for the timeout period to pass.
-
-
-### Highload wallet v2
-
-:::danger
-Legacy contract, it is suggest to use High-load wallet v3.
-:::
-
-This wallet is made for those who need to send hundreds of transactions in a short period of time. For example, crypto exchanges.
-
-It allows you to send up to `254` transactions in one smart contract call. It also uses a slightly different approach to solve replay attacks instead of seqno, so you can call this wallet several times at once to send even thousands of transactions in a second.
-
-:::caution Limitations
-Note, when dealing with highload-wallet the following limits need to be checked and taken into account.
-:::
-
-1. **Storage size limit.** Currently, size of contract storage should be less than 65535 cells. If size of
-old_queries will grow above this limit, exception in ActionPhase will be thrown and transaction will fail.
-Failed transaction may be replayed.
-2. **Gas limit.** Currently, gas limit is 1'000'000 GAS units, that means that there is a limit of how much
-old queries may be cleaned in one tx. If number of expired queries will be higher, contract will stuck.
-
-That means that it is not recommended to set too high expiration date:
-number of queries during expiration time span should not exceed 1000.
-
-Also, number of expired queries cleaned in one transaction should be below 100.
-
-
-
-Wallet source code:
- * [ton/crypto/smartcont/highload-wallet-v2-code.fc](https://github.com/ton-blockchain/ton/blob/master/crypto/smartcont/highload-wallet-v2-code.fc)
+When working with many messages in a short period, there is a need for special wallet called Highload Wallet. Read [the article](/participate/wallets/highload) for more information.
 
 ### Lockup wallet
 

docs/learn/overviews/addresses.md

@@ -0,0 +1,64 @@
+# Highload Wallet
+
+When working with many messages in a short period, there is a need for special wallet called Highload Wallet. Highload Wallet V2 was the main wallet on TON for a long time, but you had to be very careful with it. Otherwise, you could [lock all funds](https://t.me/tonstatus/88). 
+
+[With the advent of Highload Wallet V3](https://github.com/ton-blockchain/Highload-wallet-contract-v3), this problem has been solved at the contract architecture level and consumes less gas. This chapter will cover the basics of Highload Wallet V3 and important nuances to remember.
+
+## Highload Wallet v3
+
+This wallet is made for who need to send transactions at very high rates. For example, crypto exchanges.
+
+- [Source code](https://github.com/ton-blockchain/Highload-wallet-contract-v3)
+
+Any given external message (transfer request) to a Highload v3 contains:
+- a signature (512 bits) in the top level cell - the other parameters are in the ref of that cell
+- subwallet ID (32 bits)
+- message to send as a ref (the serialized internal message that will be sent)
+- send mode for the message (8 bits)
+- composite query ID - 13 bits of "shift" and 10 bits of "bit number", however the 10 bits of bit number can only go up to 1022, not 1023, and also the last such usable query ID (8388605) is reserved for emergencies and should not be normally used
+- created at, or message timestamp
+- timeout
+
+Timeout is stored in Highload as a parameter and is checked against the timeout in all requests - so the timeout for all requests is equal. The message should be not older than timeout at the time of arrival to the Highload wallet, or in code it is required that `created_at > now() - timeout`. Query IDs are stored for the purposes of replay protection for at least timeout and possibly up to 2 * timeout, however one should not expect them to be stored for longer than timeout. Subwallet ID is checked against the one stored in the wallet. Inner ref's hash is checked along with the signature against the public key of the wallet.
+
+Highload v3 can only send 1 message from any given external message, however it can send that message to itself with a special op code, allowing one to set any action cell on that internal message invocation, effectively making it possible to send up to 254 messages per 1 external message (possibly more if another message is sent to Highload wallet again among these 254).
+
+Highload v3 will always store the query ID (replay protection) once all the checks pass, however a message may not be sent due to some conditions, including but not limited to:
+- **containing state init** (such messages, if required, may be sent using the special op code to set the action cell after an internal message from Highload wallet to itself)
+- not enough balance
+- invalid message structure (that includes external out messages - only internal messages may be sent straight from the external message)
+
+Highload v3 will never execute multiple externals containing the same `query_id` **and** `created_at` - by the time it forgets any given `query_id`, the `created_at` condition will prevent such a message from executing. This effectively makes `query_id` **and** `created_at` together the "primary key" of a transfer request for Highload v3.
+
+When iterating (incrementing) query ID, it is cheaper (in terms of TON spent on fees) to iterate through bit number first, and then the shift, like when incrementing a regular number. After you've reached the last query ID (remember about the emergency query ID - see above), you can reset query ID to 0, but if Highload's timeout period has not passed yet, then the replay protection dictionary will be full and you will have to wait for the timeout period to pass.
+
+
+## Highload wallet v2
+
+:::danger
+Legacy contract, it is suggest to use Highload wallet v3.
+:::
+
+This wallet is made for those who need to send hundreds of transactions in a short period of time. For example, crypto exchanges.
+
+It allows you to send up to `254` transactions in one smart contract call. It also uses a slightly different approach to solve replay attacks instead of seqno, so you can call this wallet several times at once to send even thousands of transactions in a second.
+
+:::caution Limitations
+Note, when dealing with Highload wallet the following limits need to be checked and taken into account.
+:::
+
+1. **Storage size limit.** Currently, size of contract storage should be less than 65535 cells. If size of
+old_queries will grow above this limit, exception in ActionPhase will be thrown and transaction will fail.
+Failed transaction may be replayed.
+2. **Gas limit.** Currently, gas limit is 1'000'000 GAS units, that means that there is a limit of how much
+old queries may be cleaned in one tx. If number of expired queries will be higher, contract will stuck.
+
+That means that it is not recommended to set too high expiration date:
+number of queries during expiration time span should not exceed 1000.
+
+Also, number of expired queries cleaned in one transaction should be below 100.
+
+
+
+Wallet source code:
+ * [ton/crypto/smartcont/Highload-wallet-v2-code.fc](https://github.com/ton-blockchain/ton/blob/master/crypto/smartcont/Highload-wallet-v2-code.fc)

docs/participate/wallets/apps.mdx

@@ -0,0 +1,25 @@
+# Overview: Sharding and Split Merge in the TON Blockchain
+
+[//]: # (TODO, this is from gpt)
+
+The TON Blockchain employs advanced sharding mechanisms to enhance scalability and performance, allowing it to efficiently process a massive number of transactions. 
+The core concept is splitting the blockchain into smaller, independent pieces called **shards**. These shards can handle transactions in parallel, ensuring high throughput even as the network grows.
+
+In TON, sharding is highly dynamic. Unlike other blockchains, which have a fixed number of shards, TON can create new shards on demand. 
+As the transaction load increases, shards split, and as the load decreases, they merge. 
+This flexibility ensures that the system can adapt to varying workloads while maintaining efficiency.
+
+The **Masterchain** plays a crucial role, maintaining the network configuration and the final state of all **workchains** and **shardchains**. 
+While the masterchain is responsible for overall coordination, **workchains** operate under their specific rules, each of which can be split further into shardchains. 
+Currently, only one workchain (the **Basechain**) operates on TON.
+
+At the heart of TON's efficiency is the **Infinity Sharding Paradigm**, which treats each account as part of its own "accountchain."
+These accountchains are then aggregated into shardchain blocks, facilitating efficient transaction processing.
+
+In addition to the dynamic creation of shards, TON uses **Split Merge** functionality, which allows the network to efficiently respond to changing transaction loads. This system enhances scalability and interaction within the blockchain network, exemplifying TON's approach to resolving common blockchain challenges with a focus on efficiency and global consistency.
+
+
+## See Also
+
+* [Shards Dive In](/develop/blockchain/shards)
+* [# Infinity Sharding Paradigm](/develop/blockchain/sharding-lifecycle)