Split the receiver example to binary messages and textual messages

Author: talkol

src/routes/(examples)/03-receivers/+page.svelte

@@ -9,7 +9,6 @@
   import { Receivers } from "./Receivers";
 
   let sender: Sender;
-  let sender2: Sender;
   let contract: SandboxContract<Receivers>;
 
   $store = {

src/routes/(examples)/03-receivers/Receivers.ts

@@ -521,15 +521,9 @@ export class Receivers implements Contract {
     provider: ContractProvider,
     via: Sender,
     args: { value: bigint; bounce?: boolean | null | undefined },
-    message: "increment" | "decrement" | Add | Subtract | MultiMath | Deploy,
+    message: Add | Subtract | MultiMath | "increment" | "decrement" | Deploy,
   ) {
     let body: Cell | null = null;
-    if (message === "increment") {
-      body = beginCell().storeUint(0, 32).storeStringTail(message).endCell();
-    }
-    if (message === "decrement") {
-      body = beginCell().storeUint(0, 32).storeStringTail(message).endCell();
-    }
     if (message && typeof message === "object" && !(message instanceof Slice) && message.$$type === "Add") {
       body = beginCell().store(storeAdd(message)).endCell();
     }
@@ -539,6 +533,12 @@ export class Receivers implements Contract {
     if (message && typeof message === "object" && !(message instanceof Slice) && message.$$type === "MultiMath") {
       body = beginCell().store(storeMultiMath(message)).endCell();
     }
+    if (message === "increment") {
+      body = beginCell().storeUint(0, 32).storeStringTail(message).endCell();
+    }
+    if (message === "decrement") {
+      body = beginCell().storeUint(0, 32).storeStringTail(message).endCell();
+    }
     if (message && typeof message === "object" && !(message instanceof Slice) && message.$$type === "Deploy") {
       body = beginCell().store(storeDeploy(message)).endCell();
     }

src/routes/(examples)/03-receivers/content.md

@@ -8,8 +8,8 @@ Sending a message to a contract costs gas and is processed in the course of a tr
 
 ## Receivers
 
-Contract methods named `receive()` are the handlers that process each incoming message type. Tact will automatically route the correct message to the correct receiver listening for it.
+When designing your contract, make a list of every operation that your contract supports, then, define a message for each operation, and finally, implement a handler for each message containing the logic of what to do when it arrives.
 
-## Hardware wallets and blind signing
+Contract methods named `receive()` are the handlers that process each incoming message type. Tact will automatically route every incoming message to the correct receiver listening for it according to its type.
 
-When working with dangerous contracts that handle a lot of money, users are encouraged to use hardware wallets like [Ledger](https://www.ledger.com/). Hardware wallets cannot decode binary messages to confirm to the user what they're actually signing. Tact supports textual messages for this reason, since they can easily be confirmed with users, eliminating phishing risks.
+Messages are defined using the `message` keyword. They can carry input arguments. Notice that for integers, you must define the encoding size, just like in state variables. When somebody sends the message, they serialize it over the wire.

src/routes/(examples)/03-receivers/contract.tact

@@ -1,13 +1,16 @@
 import "@stdlib/deploy";
 
+// this message will cause our contract to add an amount to the counter
 message Add {
     amount: Int as uint32;
 }
 
+// this message will cause our contract to subtract an amount from the counter
 message Subtract {
     amount: Int as uint32;
 }
 
+// this message will cause our contract to do a complex math operation on the counter
 message MultiMath {
     add: Int as uint32;
     subtract: Int as uint32;
@@ -21,33 +24,33 @@ contract Receivers with Deployable {
     init() {
         self.val = 0;
     }
- 
-    // a textual string message, using the comment field of a transfer (great for Ledger)
-    receive("increment") {
-        self.val = self.val + 1;
-    }
-
-    // a different textual string message, you can have as many as you want
-    receive("decrement") {
-        self.val = self.val - 1;
-    }
 
-    // binary message that can carry input arguments
+    // handler for the "Add" message - this is a binary message that has an input argument (amount)
     receive(msg: Add) {
         self.val = self.val + msg.amount;
     }
 
-    // a different binary message, although its format is identical
+    // handler for the "Subtract" message - this is a different binary message although its format is identical
     receive(msg: Subtract) {
         self.val = self.val - msg.amount;
     }
 
-    // binary messages can hold multiple arguments
+    // handler for the "MultiMath" message - this is a binary message that holds multiple input arguments
     receive(msg: MultiMath) {
         self.val = self.val + msg.add;
         self.val = self.val - msg.subtract;
         self.val = self.val * msg.multiply;
     }
+
+    // handler for "increment" textual message - this is a textual string message, these cannot carry input arguments
+    receive("increment") {
+        self.val = self.val + 1;
+    }
+
+    // handler for "decrement" textual message - this is a different textual string message, you can have as many as you want
+    receive("decrement") {
+        self.val = self.val - 1;
+    }
 
     get fun value(): Int {
         return self.val;

src/routes/(examples)/03-textual-messages/+page.svelte

@@ -0,0 +1,50 @@
+<script lang="ts">
+  import { toNano, type Sender } from "ton-core";
+  import { Blockchain, type SandboxContract } from "@ton-community/sandbox";
+  import { getExample } from "$lib/helpers";
+  import store from "$lib/store";
+
+  import markdown from "./content.md?raw";
+  import tactCode from "./contract.tact?raw";
+  import { Receivers } from "./Receivers";
+
+  let sender: Sender;
+  let contract: SandboxContract<Receivers>;
+
+  $store = {
+    markdown,
+    tactCode,
+    deploy: async () => {
+      const blockchain = await Blockchain.create();
+      const deployer = await blockchain.treasury("deployer");
+      sender = deployer.getSender();
+      contract = blockchain.openContract(await Receivers.fromInit());
+      const addresses = {
+        [deployer.address.toString()]: "deployer",
+        [contract.address.toString()]: "contract",
+      };
+      return [[contract], addresses, [await contract.send(deployer.getSender(), { value: toNano(1) }, { $$type: "Deploy", queryId: 0n })]];
+    },
+    messages: {
+      increment: async () => {
+        return [await contract.send(sender, { value: toNano(1) }, "increment")];
+      },
+      decrement: async () => {
+        return [await contract.send(sender, { value: toNano(1) }, "decrement")];
+      },
+      "increment by 2": async () => {
+        return [await contract.send(sender, { value: toNano(1) }, "increment by 2")];
+      },
+      "increment by 3": async () => {
+        return [await contract.send(sender, { value: toNano(1) }, "increment by 3")];
+      },
+    },
+    getters: {
+      value: async () => {
+        return await contract.getValue();
+      },
+    },
+    prev: getExample(import.meta.url).prev,
+    next: getExample(import.meta.url).next,
+  };
+</script>