[Tolk] Modern onInternalMessage and onBouncedMessage

Instead of "FunC-style" parsing msg_cell,
use `in.senderAddress`, `in.originalForwardFee`,
that are mapped onto TVM-11 instructions

Author: tolk-vm

crypto/smartcont/tolk-stdlib/common.tolk

@@ -843,7 +843,7 @@ fun slice.remainingBitsAndRefsCount(self): (int, int)
 
 /// Checks whether a slice is empty (i.e., contains no bits of data and no cell references).
 @pure
-fun slice.isEnd(self): bool
+fun slice.isEmpty(self): bool
     asm "SEMPTY";
 
 /// Checks whether a slice has no bits of data.
@@ -1311,14 +1311,53 @@ fun sendRawMessage(msg: cell, mode: int): void
     Receiving and handling messages.
 */
 
+/// InMessage is an input for `onInternalMessage` — when your contract accepts a non-bounced message.
+/// Internally, some data exist on the stack, some can be acquired with TVM instructions.
+/// The compiler replaces `in.someField` and gets a value correctly.
+/// Example:
+/// ```
+/// fun onInternalMessage(in: InMessage) {
+///     in.senderAddress   // actually calls `INMSG_SRC` asm instruction
+///     in.body            // actually gets from a TVM stack
+/// ```
+struct InMessage {
+    senderAddress: address;         // an internal address from which the message arrived
+    valueCoins: coins;              // ton amount attached to an incoming message
+    valueExtra: dict;               // extra currencies attached to an incoming message
+    originalForwardFee: coins;      // fee that was paid by the sender
+    createdLt: uint64;              // logical time when a message was created
+    createdAt: uint32;              // unixtime when a message was created
+    body: slice;                    // message body, parse it with `lazy AllowedMsg.fromSlice(in.body)`
+}
+
+/// InMessageBounced is an input for `onBouncedMessage`.
+/// Very similar to a non-bounced input [InMessage].
+/// Note, that `bouncedBody` is currently 256 bits: 0xFFFFFFFF + 224 bits from the originally sent message.
+/// Parse it with care!
+/// Example:
+/// ```
+/// fun onBouncedMessage(in: InMessageBounced) {
+///     in.bouncedBody.skipBouncedPrefix();
+///     val originalOpcode = in.bouncedBody.loadUint(32);
+/// ```
+struct InMessageBounced {
+    senderAddress: address;         // an internal address from which the message was bounced
+    valueCoins: coins;              // ton amount attached to a message
+    valueExtra: dict;               // extra currencies attached to a message
+    originalForwardFee: coins;      // comission that the sender has payed to send this message
+    createdLt: uint64;              // logical time when a message was created (and bounced)
+    createdAt: uint32;              // unixtime when a message was created (and bounced)
+    bouncedBody: slice;             // currently 256 bits: 0xFFFFFFFF + 224 bits sent originally
+}
+
 /// Skip 0xFFFFFFFF prefix (when a message is bounced).
 @pure
 fun slice.skipBouncedPrefix(mutate self): self
     asm "32 LDU" "NIP";
 
 /// Load msgFlags from incoming message body (4 bits).
 @pure
-@deprecated("use `onInternalMessage(in: InMessage)` and `in.isBounced` instead of parsing msgCell manually")
+@deprecated("use `onBouncedMessage` handler instead of parsing msgCell flags manually")
 fun slice.loadMessageFlags(mutate self): int
     asm( -> 1 0) "4 LDU";
 
@@ -1349,3 +1388,4 @@ fun slice.skipMessageQueryId(mutate self): self
 fun builder.storeMessageQueryId(mutate self, queryId: int): self
     asm(queryId self) "64 STU";
 
+

crypto/smartcont/tolk-stdlib/gas-payments.tolk

@@ -45,16 +45,17 @@ fun calculateGasFeeWithoutFlatPrice(workchain: int8, gasUsed: coins): coins
 fun calculateStorageFee(workchain: int8, seconds: int, bits: int, cells: int): coins
     asm(cells bits seconds workchain) "GETSTORAGEFEE";
 
-/// Calculates amount of nanotoncoins you should pay to send a message of specified size.
-fun calculateMessageFee(workchain: int8, bits: int, cells: int): coins
+/// Calculates amount of nanotoncoins you should pay to send a message of a specified size.
+fun calculateForwardFee(workchain: int8, bits: int, cells: int): coins
     asm(cells bits workchain) "GETFORWARDFEE";
 
-/// Same as [calculateMessageFee], but without lump price (you have supposed to read https://docs.ton.org/develop/howto/fees-low-level)
-fun calculateMessageFeeWithoutLumpPrice(workchain: int8, bits: int, cells: int): coins
+/// Same as [calculateForwardFee], but without lump price (you have supposed to read https://docs.ton.org/develop/howto/fees-low-level)
+fun calculateForwardFeeWithoutLumpPrice(workchain: int8, bits: int, cells: int): coins
     asm(cells bits workchain) "GETFORWARDFEESIMPLE";
 
 /// Calculates fee that was paid by the sender of an incoming internal message.
-fun calculateOriginalMessageFee(workchain: int8, incomingFwdFee: coins): coins
+@deprecated("use modern `onInternalMessage` and access `in.originalForwardFee` directly")
+fun calculateOriginalForwardFee(workchain: int8, incomingFwdFee: coins): coins
     asm(incomingFwdFee workchain) "GETORIGINALFWDFEE";
 
 /// Returns the amount of nanotoncoins current contract debts for storage. ("due" and "debt" are synonyms)

tolk-tester/tests/cells-slices.tolk

@@ -112,11 +112,11 @@ fun slice.sumNumbersInSlice(mutate self): int {
 fun test10() {
     var ref = beginCell().storeInt(100, 32).endCell();
     var s: slice = beginCell().storeInt(1, 32).storeInt(2, 32).storeRef(ref).endCell().beginParse();
-    var result = (s.remainingBitsCount(), s.sumNumbersInSlice(), s.remainingBitsCount(), s.isEnd(), s.isEndOfBits(), s.isEndOfRefs());
+    var result = (s.remainingBitsCount(), s.sumNumbersInSlice(), s.remainingBitsCount(), s.isEmpty(), s.isEndOfBits(), s.isEndOfRefs());
     var ref2: cell = s.loadRef();
     var s2: slice = ref2.beginParse();
     s.assertEnd();
-    return (result, s2.loadInt(32), s2.isEnd());
+    return (result, s2.loadInt(32), s2.isEmpty());
 }
 
 @method_id(111)

tolk-tester/tests/handle-msg-1.tolk

@@ -0,0 +1,134 @@
+
+fun setTvmRegisterC7(c7: [tuple]): void
+    asm "c7 POP";
+
+@noinline
+fun emulateC7PresentForTests(bounced: bool, senderAddress: address, fwdFee: coins, createdLt: int, createdAt: int, valueCoins: coins, valueExtra: dict) {
+    var c7_inner = createEmptyTuple();
+    repeat (17) {
+        c7_inner.push(null);
+    }
+
+    var inmsgparams = createEmptyTuple();
+    inmsgparams.push(null);        // bounce (not present in InMessage)
+    inmsgparams.push(bounced);
+    inmsgparams.push(senderAddress);
+    inmsgparams.push(fwdFee);
+    inmsgparams.push(createdLt);
+    inmsgparams.push(createdAt);
+    inmsgparams.push(null);        // orig value (not present in InMessage)
+    inmsgparams.push(valueCoins);  // in onInternalMessage, from a stack; in onBouncedMessage, from TVM
+    inmsgparams.push(valueExtra);
+    inmsgparams.push(null);        // state init (not present in InMessage)
+    c7_inner.push(inmsgparams);
+
+    setTvmRegisterC7([c7_inner]);
+}
+
+fun invokeTest(body: slice, method_id: int): void
+    asm "c3 PUSH" "EXECUTE";        // stack: body
+
+@method_id(101)
+fun handle1(in: InMessage) {
+    return in.senderAddress.getWorkchain();
+}
+
+@method_id(201)
+fun entrypoint1() {
+    emulateC7PresentForTests(true, address("EQCtrtTXEAoSpoERmiqOnICe9LHxn2N89N4BH9qdHlrG-U0i"), 100, 20, 30, 900, null);
+    invokeTest("", 101);
+}
+
+@method_id(102)
+fun handle2(in: InMessage) {
+    return (in.valueCoins, in.senderAddress.isInternal());
+}
+
+@method_id(202)
+fun entrypoint2() {
+    emulateC7PresentForTests(false, address("EQCtrtTXEAoSpoERmiqOnICe9LHxn2N89N4BH9qdHlrG-U0i"), 100, 20, 30, 888, null);
+    invokeTest("", 102);
+}
+
+@method_id(103)
+fun handle3(`in()`: InMessage) {
+    return (
+        `in()`.senderAddress.getWorkchainAndHash(),
+        `in()`.valueCoins,
+        `in()`.valueExtra,
+        `in()`.createdLt,
+        `in()`.createdAt,
+        `in()`.body.isEmpty(),
+    )
+}
+
+@method_id(203)
+fun entrypoint3() {
+    emulateC7PresentForTests(true, address("-1:000000000000000000000000000000000000000000000000000000000000FFFF"), 100, 20, 30, 999, null);
+    invokeTest("00", 103);
+}
+
+fun onInternalMessage(in: InMessage) {
+    __expect_type(in.body, "slice");
+    __expect_type(in.senderAddress, "address");
+    __expect_type(in.valueCoins, "coins");
+    return in.originalForwardFee;
+}
+
+/**
+@testcase | 201 |  | 0
+@testcase | 202 |  | 888 -1
+@testcase | 203 |  | -1 65535 999 (null) 20 30 0
+
+@fif_codegen
+"""
+  handle1() PROC:<{             //  in.body
+    DROP                        //
+    INMSG_SRC                   //  '1
+    REWRITESTDADDR
+    DROP                        //  '3
+  }>
+"""
+
+@fif_codegen
+"""
+  handle2() PROC:<{             //  in.body
+    DROP                        //
+    INMSG_VALUE                 //  '1
+    INMSG_SRC                   //  '1 '3
+    b{10} SDBEGINSQ
+    NIP                         //  '1 '5
+  }>
+"""
+
+@fif_codegen
+"""
+  handle3() PROC:<{
+    INMSG_SRC
+    REWRITESTDADDR
+    INMSG_VALUE
+    INMSG_VALUEEXTRA
+    INMSG_LT
+    INMSG_UTIME
+    s0 s6 XCHG
+    SEMPTY
+    s5 s6 XCHG
+    s4 s5 XCHG
+    s3 s4 XCHG
+    s1 s3 s0 XCHG3
+  }>
+"""
+
+@fif_codegen
+"""
+  onInternalMessage() PROC:<{   //  in.body
+    DROP
+    INMSG_BOUNCED
+    0 THROWIF
+    INMSG_FWDFEE
+    0 PUSHINT
+    GETORIGINALFWDFEE
+  }>
+"""
+
+ */

tolk-tester/tests/handle-msg-2.tolk

@@ -0,0 +1,23 @@
+
+@method_id(101)
+fun test1() {
+    return 0;
+}
+
+fun onInternalMessage(in: InMessage) {
+    return in.valueExtra;
+}
+
+/**
+@testcase | 101 | | 0
+
+@fif_codegen
+"""
+  onInternalMessage() PROC:<{
+    DROP
+    INMSG_BOUNCED
+    0 THROWIF
+    INMSG_VALUEEXTRA
+  }>
+"""
+*/

tolk-tester/tests/handle-msg-3.tolk

@@ -0,0 +1,32 @@
+
+@method_id(101)
+fun test1() {
+    return 0;
+}
+
+fun onBouncedMessage(in: InMessageBounced) {
+    in.bouncedBody.skipBouncedPrefix();
+    throw in.bouncedBody.loadUint(32);
+}
+
+fun onInternalMessage(in: InMessage) {
+    return in.body;
+}
+
+/**
+@testcase | 101 | | 0
+
+@fif_codegen
+"""
+  onInternalMessage() PROC:<{
+    INMSG_BOUNCED
+    IFJMP:<{
+       32 LDU
+       NIP
+       32 LDU
+       DROP
+       THROWANY
+    }>                      	//  in.body
+  }>
+"""
+*/

tolk-tester/tests/handle-msg-4.tolk

@@ -0,0 +1,40 @@
+
+@method_id(101)
+fun test1() {
+    return 0;
+}
+
+@inline_ref
+fun onBouncedMessage(in: InMessageBounced) {
+    contract.setData(createEmptyCell());
+}
+
+fun onInternalMessage(in: InMessage) {
+    return 123;
+}
+
+/**
+@testcase | 101 | | 0
+
+@fif_codegen
+"""
+  onBouncedMessage() PROCREF:<{	//  in.body
+    DROP
+    <b b> PUSHREF
+    c4 POP
+  }>
+"""
+
+@fif_codegen
+"""
+  onInternalMessage() PROC:<{   //  in.body
+    INMSG_BOUNCED               //  in.body '1
+    IFJMP:<{                    //  in.body
+      onBouncedMessage() INLINECALLDICT
+    }>
+    DROP
+    123 PUSHINT
+  }>
+"""
+
+ */

tolk-tester/tests/handle-msg-5.tolk

@@ -0,0 +1,39 @@
+
+@method_id(101)
+fun test1() {
+    return 0;
+}
+
+@noinline
+fun onBouncedMessage(in: InMessageBounced) {
+    throw in.valueCoins;
+}
+
+fun onInternalMessage(in: InMessage) {
+    return in.valueCoins;
+}
+
+/**
+@testcase | 101 | | 0
+
+@fif_codegen
+"""
+  onBouncedMessage() PROC:<{
+    DROP
+    INMSG_VALUE
+    THROWANY
+  }>
+"""
+
+@fif_codegen
+"""
+  onInternalMessage() PROC:<{   //  in.body
+    INMSG_BOUNCED               //  in.body '1
+    IFJMP:<{                    //  in.body
+      onBouncedMessage() CALLDICT       //
+    }>                          //  in.body
+    DROP                        //
+    INMSG_VALUE                 //  '3
+  }>
+"""
+  */