Refactor unpacked in_msg params

Author: Rexagon

Cargo.toml

@@ -39,9 +39,9 @@ tracing = "0.1"
 tracing-subscriber = "0.3"
 tracing-test = "0.2"
 
-everscale-asm-macros = { git = "https://github.com/broxus/everscale-asm.git", rev = "bbd284a72676300c89ab074bd39cd91fde21d597" }
+everscale-asm-macros = { git = "https://github.com/broxus/everscale-asm.git", rev = "1ca1675c0e9b7fa8dde3a5f7422ebd3bd169fb62" }
 
 tycho-vm = { path = "./vm" }
 
 [patch.crates-io]
-everscale-types = { git = "https://github.com/broxus/everscale-types.git", rev = "3b71c951d876213ad4e03f071182be0b1711d77c" }
+everscale-types = { git = "https://github.com/broxus/everscale-types.git", rev = "fee2eb43c3cbd0c5180a6d4c359e5bb415fb9d72" }

executor/src/phase/compute.rs

@@ -1,12 +1,12 @@
 use anyhow::Result;
 use everscale_types::models::{
     AccountState, AccountStatus, ComputePhase, ComputePhaseSkipReason, CurrencyCollection,
-    ExecutedComputePhase, SkippedComputePhase, StateInit, TickTock,
+    ExecutedComputePhase, IntAddr, IntMsgInfo, MsgType, SkippedComputePhase, StateInit, TickTock,
 };
 use everscale_types::num::Tokens;
 use everscale_types::prelude::*;
 use num_bigint::{BigInt, Sign};
-use tycho_vm::{tuple, SafeRc, SmcInfoBase, Stack, VmState};
+use tycho_vm::{tuple, SafeRc, SmcInfoBase, Stack, Tuple, UnpackedInMsgSmcInfo, VmState};
 
 use crate::phase::receive::{MsgStateInit, ReceivedMessage};
 use crate::util::{
@@ -147,6 +147,7 @@ impl ExecutorState<'_> {
             });
             return Ok(res);
         }
+
         // Apply internal message state.
         let state_libs;
         let msg_libs;
@@ -180,7 +181,7 @@ impl ExecutorState<'_> {
                     &self.address.address
                 };
 
-                if from_msg.hash != *target_hash || from_msg.parsed.split_depth.is_some() {
+                if from_msg.root_hash() != target_hash || from_msg.parsed.split_depth.is_some() {
                     // State hash mismatch, cannot use this state.
                     // We also forbid using `split_depth` (for now).
                     res.compute_phase = ComputePhase::Skipped(SkippedComputePhase {
@@ -227,7 +228,7 @@ impl ExecutorState<'_> {
             }
             (Some(from_msg), AccountState::Active(StateInit { libraries, .. })) => {
                 // Check if a state from the external message has the correct hash.
-                if is_external && from_msg.hash != self.address.address {
+                if is_external && from_msg.root_hash() != &self.address.address {
                     res.compute_phase = ComputePhase::Skipped(SkippedComputePhase {
                         reason: ComputePhaseSkipReason::BadState,
                     });
@@ -243,6 +244,12 @@ impl ExecutorState<'_> {
             }
         }
 
+        // Unpack internal message.
+        let unpacked_in_msg = match ctx.input.in_msg() {
+            Some(msg) => msg.make_tuple()?,
+            None => None,
+        };
+
         // Build VM stack and register info.
         let stack = self.prepare_vm_stack(ctx.input);
 
@@ -262,9 +269,8 @@ impl ExecutorState<'_> {
             .with_storage_fees(ctx.storage_fee)
             .require_ton_v6()
             .with_unpacked_config(self.config.unpacked.as_tuple())
-            .require_ton_v9()
             .require_ton_v11()
-            .with_in_message(ctx.input.in_msg().map(|x| &x.root))?;
+            .with_unpacked_in_msg(unpacked_in_msg);
 
         let libraries = (msg_libs, state_libs, &self.params.libraries);
         let mut vm = VmState::builder()
@@ -364,16 +370,16 @@ impl ExecutorState<'_> {
         SafeRc::new(Stack::with_items(match input {
             TransactionInput::Ordinary(msg) => {
                 tuple![
-                    int self.balance.tokens.into_inner(),
-                    int msg.balance_remaining.tokens.into_inner(),
+                    int self.balance.tokens,
+                    int msg.balance_remaining.tokens,
                     cell msg.root.clone(),
                     slice msg.body.clone(),
                     int if msg.is_external { -1 } else { 0 },
                 ]
             }
             TransactionInput::TickTock(ty) => {
                 tuple![
-                    int self.balance.tokens.into_inner(),
+                    int self.balance.tokens,
                     int BigInt::from_bytes_be(Sign::Plus, self.address.address.as_array()),
                     int match ty {
                         TickTock::Tick => 0,
@@ -386,6 +392,42 @@ impl ExecutorState<'_> {
     }
 }
 
+impl ReceivedMessage {
+    fn make_tuple(&self) -> Result<Option<SafeRc<Tuple>>, everscale_types::error::Error> {
+        let mut cs = self.root.as_slice()?;
+        if MsgType::load_from(&mut cs)? != MsgType::Int {
+            return Ok(None);
+        }
+
+        // Get `src` addr range.
+        let src_addr_slice = {
+            let mut cs = cs;
+            // Skip flags.
+            cs.skip_first(3, 0)?;
+            let mut addr_slice = cs;
+            // Read `src`.
+            IntAddr::load_from(&mut cs)?;
+            addr_slice.skip_last(cs.size_bits(), cs.size_refs())?;
+            addr_slice.range()
+        };
+
+        let info = IntMsgInfo::load_from(&mut cs)?;
+
+        let unpacked = UnpackedInMsgSmcInfo {
+            bounce: info.bounce,
+            bounced: info.bounced,
+            src_addr: (src_addr_slice, self.root.clone()).into(),
+            fwd_fee: info.fwd_fee,
+            created_lt: info.created_lt,
+            created_at: info.created_at,
+            original_value: info.value.tokens,
+            remaining_value: self.balance_remaining.clone(),
+            state_init: self.init.as_ref().map(|init| init.root.clone()),
+        };
+        Ok(Some(unpacked.into_tuple()))
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use everscale_asm_macros::tvmasm;

executor/src/phase/receive.rs

@@ -97,7 +97,7 @@ impl ExecutorState<'_> {
         let init = if slice.load_bit()? {
             Some(if slice.load_bit()? {
                 // State init as reference.
-                let state_root = slice.load_reference()?;
+                let state_root = slice.load_reference_cloned()?;
                 anyhow::ensure!(
                     !state_root.is_exotic(),
                     "state init must be an ordinary cell"
@@ -108,7 +108,7 @@ impl ExecutorState<'_> {
                 anyhow::ensure!(slice.is_empty(), "state init contains extra data");
 
                 MsgStateInit {
-                    hash: *state_root.repr_hash(),
+                    root: state_root,
                     parsed,
                 }
             } else {
@@ -122,7 +122,7 @@ impl ExecutorState<'_> {
                 let state_root = CellBuilder::build_from(state_init_cs)?;
 
                 MsgStateInit {
-                    hash: *state_root.repr_hash(),
+                    root: state_root,
                     parsed,
                 }
             })
@@ -194,12 +194,18 @@ pub struct ReceivedMessage {
 /// Message state init.
 #[derive(Debug, Clone)]
 pub struct MsgStateInit {
-    /// [`StateInit`] hash.
-    pub hash: HashBytes,
+    /// Serialized [`StateInit`].
+    pub root: Cell,
     /// Parsed [`StateInit`].
     pub parsed: StateInit,
 }
 
+impl MsgStateInit {
+    pub fn root_hash(&self) -> &HashBytes {
+        self.root.repr_hash()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use everscale_types::models::{
@@ -245,7 +251,7 @@ mod tests {
             let target = StateInit::default();
             assert_eq!(init.parsed, target);
             let target_hash = *CellBuilder::build_from(&target).unwrap().repr_hash();
-            assert_eq!(init.hash, target_hash);
+            assert_eq!(init.root_hash(), &target_hash);
         }
         assert!(msg.body.0.is_empty());
         assert_eq!(msg.balance_remaining, CurrencyCollection::ZERO);