feat(docs): how the storage is handled with regards to return and throw(0) patterns (#3419)

Author: novusnota

docs/src/content/docs/book/bounced.mdx

@@ -76,4 +76,8 @@ contract MyContract {
 
 On TON, bounced message bodies have a 32 bits prefix, where all bits are set, i.e., with `0xFFFFFFFF{:tact}`. However, since that prefix is always the same for all bounced messages, Tact cuts it off for your convenience, keeping only the remaining 256 bits of the payload, which usually starts with a 32-bit message opcode.
 
+## Contract storage handling
+
+Bounced message receivers handle contract storage just as [internal message receivers](/book/receive#contract-storage-handling) do. In addition, the empty [`return{:tact}` statement](/book/statements#return) and the [`throw(0){:tact}`](/ref/core-debug#throw) patterns [work the same](/book/receive#contract-storage-handling).
+
 [message]: /book/structs-and-messages#messages

docs/src/content/docs/book/external.mdx

@@ -46,15 +46,22 @@ After accepting a message, the contract can use as much gas as it wants. This is
 
 When processing an external message, the `context` and `sender` functions are not available. This is because there is no context available for external messages. Therefore, you cannot use the `context` and `sender` functions in external messages. You need to carefully test your contract to ensure that it does not use the `context` and `sender` functions.
 
-## Enable External Messages Support
+## Enable external message receivers support
 
-To enable external message support, please enable it in the project configuration file:
+You can enable the external message support in the [`tact.config.json`](/book/config) by setting the [`external`](/book/config#options-external) option to `true{:json}`.
 
-```json
+```json title="tact.config.json" {8}
 {
-  "options": {
-    "external": true
-  }
+  "projects": [
+    {
+      "name": "some_prefix",
+      "path": "./contract.tact",
+      "output": "./contract_output",
+      "options": {
+        "external": true
+      }
+    }
+  ]
 }
 ```
 
@@ -78,4 +85,8 @@ contract SampleContract {
 }
 ```
 
-External receivers follow the same execution order conventions as [internal receivers](/book/receive).
+External receivers follow the same execution order conventions as [internal receivers](/book/receive).
+
+## Contract storage handling
+
+External message receivers handle contract storage just as [internal message receivers](/book/receive#contract-storage-handling) do. In addition, the empty [`return{:tact}` statement](/book/statements#return) and the [`throw(0){:tact}`](/ref/core-debug#throw) patterns [work the same](/book/receive#contract-storage-handling).

docs/src/content/docs/book/functions.mdx

@@ -928,7 +928,7 @@ extends fun doWith(self: Slice) {}
 
 All functions return a value. If the function does not have an explicit return type specified, it has an implicit return type of `void` — a pseudo-value that represents "nothing" in the Tact compiler. This also applies to the functions that do not allow specifying a return type, such as [receivers](#receivers) or [`init(){:tact}`](#init).
 
-Moreover, execution of any function can be ended prematurely with the [`return{:tact}` statement](/book/statements#return). This is also true for the [receiver functions](#receivers) and [`init(){:tact}`], where empty `return{:tact}` statements are allowed.
+Moreover, execution of any function can be ended prematurely with the [`return{:tact}` statement](/book/statements#return). This is also true for receiver functions and `init(){:tact}` function, where empty `return{:tact}` statements are allowed.
 
 ```tact
 contract GreedyCashier(owner: Address) {

docs/src/content/docs/book/receive.mdx

@@ -236,3 +236,55 @@ contract JettonWallet(
     }
 }
 ```
+
+## Contract storage handling
+
+Blockchain keeps each smart contract's code and data in its state. After receiving a message, the contract's storage data is loaded, and once processing in the receiver is complete, a new state of the contract is saved.
+
+The loads and stores are managed by Tact, which implicitly adds relevant code during compilation. That way, the user only needs to think of using receivers to handle message bodies.
+
+As Tact writes relevant code to automatically save the contract's state after the end of each receiver's logic, you can safely skip some of the steps in your code and jump to the end of processing the receiver with the [`return{:tact}` statement](/book/statements#return).
+
+```tact {5}
+contract GreedyCashier(owner: Address) {
+    receive() {
+        // Stop the execution if the message is not from an `owner`.
+        if (sender() != self.owner) {
+            return;
+        }
+        // Otherwise, forward excesses back to the sender.
+        cashback(sender());
+    }
+}
+```
+
+If the Tact compiler can deduce that a certain receiver does not modify the contract's state, then the storage-saving logic is omitted, and some extra gas is saved as a result.
+
+Furthermore, to make an early exit from the receiver without saving the new contract's state, use the [`throw(0){:tact}`](/ref/core-debug#throw) idiom. It will immediately and successfully terminate the execution of the compute phase of the contract and skip the code generated by Tact to save the contract's state. Conversely, changes to data made before calling `throw(){:tact}` in with this function will be lost unless you manually save them beforehand.
+
+That said, when using the `throw(0){:tact}` idiom, make sure to double-check and test cover your every move so that the contract's data won't become corrupt or inadvertently gone.
+
+```tact {18-20}
+// This function manually saves contract data Cell
+asm fun customSetData(data: Cell) { c4 POP }
+
+contract WalletV4(
+    seqno: Int as uint32,
+    // ...other parameters...
+) {
+    // ...
+    external(_: Slice) {
+        // ...various prior checks...
+
+        acceptMessage();
+        self.seqno += 1;
+
+        // Manually saving the contract's state
+        customSetData(self.toCell());
+
+        // And halting the transaction to prevent a secondary save implicitly
+        // added by Tact after the main execution logic of the receiver
+        throw(0);
+    }
+}
+```