Merge pull request #128 from tonlabs/updated-contract

Updated contract

Author: melsomino

CHANGELOG.md

@@ -1,6 +1,10 @@
 # Release Notes
 All notable changes to this project will be documented in this file.
 
+## Jun 03, 2020
+### New
+- local run functions return updated contract state when running with `full_run = true`
+
 ## May 28, 2020
 ### New
 - error resolving by local message processing

ton_client/client/src/contracts/run.rs

@@ -123,7 +123,14 @@ pub struct ParamsOfDecodeUnknownRun {
 #[derive(Serialize, Deserialize)]
 pub(crate) struct ResultOfRun {
     pub output: serde_json::Value,
-    pub fees: Option<RunFees>
+    pub fees: RunFees
+}
+
+#[derive(Serialize, Deserialize)]
+pub(crate) struct ResultOfLocalRun {
+    pub output: serde_json::Value,
+    pub fees: Option<RunFees>,
+    pub account: Option<Contract>
 }
 
 #[derive(Serialize, Deserialize)]
@@ -264,7 +271,7 @@ pub(crate) fn process_transaction(
     let fees = transaction.calc_fees().into();
     let output = process_out_messages(&transaction.out_messages, abi, function)?;
 
-    Ok( ResultOfRun { output, fees: Some(fees) } )
+    Ok( ResultOfRun { output, fees: fees } )
 }
 
 pub(crate) fn serialize_message(msg: TvmMessage) -> ApiResult<(Vec<u8>, String)> {
@@ -274,7 +281,7 @@ pub(crate) fn serialize_message(msg: TvmMessage) -> ApiResult<(Vec<u8>, String)>
     Ok((msg, id.to_string()))
 }
 
-pub(crate) fn local_run(context: &mut ClientContext, params: ParamsOfLocalRun) -> ApiResult<ResultOfRun> {
+pub(crate) fn local_run(context: &mut ClientContext, params: ParamsOfLocalRun) -> ApiResult<ResultOfLocalRun> {
     debug!("-> contracts.run.local({}, {:?})",
         params.address.clone(),
         params.call_set.clone()
@@ -293,7 +300,7 @@ pub(crate) fn local_run(context: &mut ClientContext, params: ParamsOfLocalRun) -
         Some(context), params.call_set, key_pair.as_ref(), address, account, params.full_run, params.time)
 }
 
-pub(crate) fn local_run_msg(context: &mut ClientContext, params: ParamsOfLocalRunWithMsg) -> ApiResult<ResultOfRun> {
+pub(crate) fn local_run_msg(context: &mut ClientContext, params: ParamsOfLocalRunWithMsg) -> ApiResult<ResultOfLocalRun> {
     debug!("-> contracts.run.local.msg({}, {}, {})",
         params.address.clone(),
         params.function_name.clone().unwrap_or_default(),
@@ -538,7 +545,7 @@ pub(crate) fn do_local_run(
     account: Option<Contract>,
     full_run: bool,
     time: Option<u32>,
-) -> ApiResult<ResultOfRun> {
+) -> ApiResult<ResultOfLocalRun> {
 
     let msg = Contract::construct_call_message_json(
         address.clone(), call_set.clone().into(), false, keys, None, None)
@@ -564,7 +571,7 @@ pub(crate) fn do_local_run_msg(
     msg: TvmMessage,
     full_run: bool,
     time: Option<u32>,
-) -> ApiResult<ResultOfRun> {
+) -> ApiResult<ResultOfLocalRun> {
 
     let contract = match account {
         // load contract data from node manually
@@ -593,7 +600,7 @@ pub(crate) fn do_local_run_msg(
     };
 
     if full_run {
-        let transaction = contract.local_call(msg, time)
+        let result = contract.local_call(msg, time)
             .map_err(|err| 
                 match err.downcast_ref::<ton_sdk::SdkError>() {
                     Some(ton_sdk::SdkError::ContractError(exit_code)) =>
@@ -602,14 +609,20 @@ pub(crate) fn do_local_run_msg(
                         ApiError::low_balance(&address),
                     _ => ApiError::contracts_local_run_failed(err)
                 })?;
-        process_transaction(transaction, abi, function_name, &address, false)
+        let run_result = process_transaction(result.transaction, abi, function_name, &address, false)?;
+        Ok(ResultOfLocalRun {
+            output: run_result.output,
+            fees: Some(run_result.fees),
+            account: Some(result.updated_account),
+        })
     } else {
         let messages = contract.local_call_tvm(msg)
             .map_err(|err| ApiError::contracts_local_run_failed(err))?;
 
-        Ok(ResultOfRun {
+        Ok(ResultOfLocalRun {
             output: process_out_messages(&messages, abi, function_name)?,
-            fees: None
+            fees: None,
+            account: None
         })
     }
 }

ton_sdk/src/contract.rs

@@ -156,28 +156,29 @@ const ACCOUNT_FIELDS: &str = r#"
 "#;
 
 // The struct represents value of some addititonal currency
-#[derive(Deserialize, Default, Debug, Clone)]
+#[derive(Serialize, Deserialize, Default, Debug, Clone)]
 pub struct OtherCurrencyValue {
     currency: u32,
-    value: u128,
+    #[serde(with = "json_helper::uint")]
+    value: u64,
 }
 
 // The struct represents smart contract and allows
 // to deploy and call it, to get some contract's properties.
 // Don't forget - in TON blockchain Contract and Account are the same substances.
-#[derive(Deserialize, Default, Debug)]
+#[derive(Serialize, Deserialize, Default, Debug)]
 #[serde(default)]
 pub struct Contract {
-    #[serde(deserialize_with = "json_helper::deserialize_address_int_from_string")]
+    #[serde(with = "json_helper::address")]
     pub id: MsgAddressInt,
-    #[serde(deserialize_with = "json_helper::deserialize_account_status")]
+    #[serde(with = "json_helper::account_status")]
     pub acc_type: AccountStatus,
-    #[serde(deserialize_with = "json_helper::deserialize_uint_from_string")]
+    #[serde(with = "json_helper::uint")]
     pub balance: u64,
     pub balance_other: Option<Vec<OtherCurrencyValue>>,
-    #[serde(deserialize_with = "json_helper::deserialize_tree_of_cells_opt_cell")]
+    #[serde(with = "json_helper::opt_cell")]
     pub code: Option<Cell>,
-    #[serde(deserialize_with = "json_helper::deserialize_tree_of_cells_opt_cell")]
+    #[serde(with = "json_helper::opt_cell")]
     pub data: Option<Cell>,
     pub last_paid: u32,
 }
@@ -644,6 +645,12 @@ pub struct MessageToSign {
     pub expire: Option<u32>,
 }
 
+pub struct LocalCallResult {
+    pub transaction: Transaction,
+    pub updated_account: Contract,
+    pub updated_account_root: Cell
+}
+
 impl Contract {
     /// Returns contract's address
     pub fn address(&self) -> MsgAddressInt {
@@ -694,7 +701,7 @@ impl Contract {
             |currency, value| -> Result<bool> {
                 balance_other.push(OtherCurrencyValue {
                     currency,
-                    value: num_traits::ToPrimitive::to_u128(value.value()).ok_or(
+                    value: num_traits::ToPrimitive::to_u64(value.value()).ok_or(
                         error!(SdkError::InvalidData { msg: "Account's other currency balance is too big".to_owned() })
                     )?,
                 });
@@ -797,15 +804,21 @@ impl Contract {
 
     /// Invokes local transaction executor instance with provided inbound message.
     /// Returns outbound messages generated by contract function and transaction fees
-    pub fn local_call(&self, message: TvmMessage, time: Option<u32>) -> Result<Transaction> {
+    pub fn local_call(&self, message: TvmMessage, time: Option<u32>) -> Result<LocalCallResult> {
         // TODO: get real config
-        let transaction = local_tvm::executor::call_executor(
+        let (transaction, account_root) = local_tvm::executor::call_executor(
             self.to_account()?,
             message,
             BlockchainConfig::default(),
             time.unwrap_or(Self::now()))?;
 
-        Transaction::try_from(transaction)
+        let transaction = Transaction::try_from(transaction)?;
+        let updated_account = Self::from_cells(account_root.clone().into())?;
+        Ok(LocalCallResult {
+            transaction,
+            updated_account,
+            updated_account_root: account_root
+        })
     }
 
     /// Invokes local transaction executor instance with provided inbound message.
@@ -818,7 +831,7 @@ impl Contract {
         abi: String,
         key_pair: Option<&Keypair>,
         time: Option<u32>
-    ) -> Result<Transaction> {
+    ) -> Result<LocalCallResult> {
         // pack params into bag of cells via ABI
         let msg_body = ton_abi::encode_function_call(abi, func, header, input, false, key_pair)?;
 

ton_sdk/src/json_helper.rs

@@ -64,6 +64,34 @@ impl<'de> serde::de::Visitor<'de> for U8Visitor {
     }
 }
 
+pub mod opt_cell {
+    use super::*;
+
+    pub fn deserialize<'de, D>(d: D) -> Result<Option<Cell>, D::Error>
+        where D: serde::Deserializer<'de>
+    {
+        let b64 = d.deserialize_option(StringVisitor)?;
+
+        if "null" == b64 {
+            Ok(None)
+        } else {
+            Ok(Some(deserialize_tree_of_cells_from_base64::<D>(&b64)?))
+        }
+    }
+
+    pub fn serialize<S>(value: &Option<Cell>, serializer: S) -> Result<S::Ok, S::Error> 
+        where S: serde::Serializer 
+    {
+        if let Some(cell) = value {
+            let str_value = base64::encode(&ton_types::serialize_toc(&cell).map_err(|err|
+                serde::ser::Error::custom(format!("Cannot serialize BOC: {}", err)))?);
+            serializer.serialize_some(&str_value)
+        } else {
+            serializer.serialize_none()
+        }
+    }
+}
+
 pub fn deserialize_tree_of_cells_from_base64<'de, D>(b64: &str) -> Result<Cell, D::Error>
     where D: serde::Deserializer<'de>
 {
@@ -74,42 +102,50 @@ pub fn deserialize_tree_of_cells_from_base64<'de, D>(b64: &str) -> Result<Cell,
         .map_err(|err| D::Error::custom(format!("BOC read error: {}", err)))
 }
 
-pub fn deserialize_tree_of_cells_opt_cell<'de, D>(d: D) -> Result<Option<Cell>, D::Error>
-    where D: serde::Deserializer<'de>
-{
-    let b64 = d.deserialize_option(StringVisitor)?;
+pub mod address {
+    use super::*;
+
+    pub fn deserialize<'de, D>(d: D) -> Result<MsgAddressInt, D::Error>
+        where D: serde::Deserializer<'de>
+    {
+        let string = d.deserialize_string(StringVisitor)?;
 
-    if "null" == b64 {
-        Ok(None)
-    } else {
-        Ok(Some(deserialize_tree_of_cells_from_base64::<D>(&b64)?))
+        MsgAddressInt::from_str(&string)
+            .map_err(|err| D::Error::custom(format!("Address parsing error: {}", err)))
+    }
+
+    pub fn serialize<S>(value: &MsgAddressInt, serializer: S) -> Result<S::Ok, S::Error> 
+        where S: serde::Serializer 
+    {
+        serializer.serialize_str(&value.to_string())
     }
 }
 
-pub fn deserialize_address_int_from_string<'de, D>(d: D) -> Result<MsgAddressInt, D::Error>
-    where D: serde::Deserializer<'de>
-{
-    let string = d.deserialize_string(StringVisitor)?;
+pub mod uint {
+    use super::*;
 
-    MsgAddressInt::from_str(&string)
-         .map_err(|err| D::Error::custom(format!("Address parsing error: {}", err)))
-}
+    pub fn deserialize<'de, D>(d: D) -> Result<u64, D::Error>
+        where D: serde::Deserializer<'de>
+    {
+        let string = d.deserialize_option(StringVisitor)?;
 
-pub fn deserialize_uint_from_string<'de, D>(d: D) -> Result<u64, D::Error>
-    where D: serde::Deserializer<'de>
-{
-    let string = d.deserialize_option(StringVisitor)?;
+        if "null" == string {
+            return Ok(0);
+        }
 
-    if "null" == string {
-        return Ok(0);
-    }
+        if !string.starts_with("0x") {
+            return Err(D::Error::custom(format!("Number parsing error: number must be prefixed with 0x ({})", string)));
+        }
 
-    if !string.starts_with("0x") {
-        return Err(D::Error::custom(format!("Number parsing error: number must be prefixed with 0x ({})", string)));
+        u64::from_str_radix(&string[2..], 16)
+            .map_err(|err| D::Error::custom(format!("Error parsing number: {}", err)))
     }
 
-    u64::from_str_radix(&string[2..], 16)
-        .map_err(|err| D::Error::custom(format!("Error parsing number: {}", err)))
+    pub fn serialize<S>(value: &u64, serializer: S) -> Result<S::Ok, S::Error> 
+        where S: serde::Serializer 
+    {
+        serializer.serialize_str(&format!("0x{:x}", value))
+    }
 }
 
 pub fn deserialize_tr_state<'de, D>(d: D) -> Result<TransactionProcessingStatus, D::Error>
@@ -174,17 +210,33 @@ pub fn deserialize_message_type<'de, D>(d: D) -> Result<MessageType, D::Error>
     }
 }
 
-pub fn deserialize_account_status<'de, D>(d: D) -> Result<AccountStatus, D::Error>
-    where D: serde::Deserializer<'de>
-{
-    let num = d.deserialize_u8(U8Visitor)?;
+pub mod account_status {
+    use super::*;
 
-    match num {
-        0 => Ok(AccountStatus::AccStateUninit),
-        1 => Ok(AccountStatus::AccStateActive),
-        2 => Ok(AccountStatus::AccStateFrozen),
-        3 => Ok(AccountStatus::AccStateNonexist),
-        num => Err(D::Error::custom(format!("Invalid account status: {}", num)))
+    pub fn deserialize<'de, D>(d: D) -> Result<AccountStatus, D::Error>
+        where D: serde::Deserializer<'de>
+    {
+        let num = d.deserialize_u8(U8Visitor)?;
+
+        match num {
+            0 => Ok(AccountStatus::AccStateUninit),
+            1 => Ok(AccountStatus::AccStateActive),
+            2 => Ok(AccountStatus::AccStateFrozen),
+            3 => Ok(AccountStatus::AccStateNonexist),
+            num => Err(D::Error::custom(format!("Invalid account status: {}", num)))
+        }
+    }
+
+    pub fn serialize<S>(value: &AccountStatus, serializer: S) -> Result<S::Ok, S::Error> 
+        where S: serde::Serializer 
+    {
+        serializer.serialize_u8(        
+            match value {
+                AccountStatus::AccStateUninit => 0,
+                AccountStatus::AccStateActive => 1,
+                AccountStatus::AccStateFrozen => 2,
+                AccountStatus::AccStateNonexist => 3
+        })
     }
 }
 

ton_sdk/src/local_tvm.rs

@@ -136,25 +136,15 @@ pub mod executor {
     };
     use ton_executor::ExecutorError;
 
-    #[derive(Default, Debug)]
-    pub struct TransactionFees {
-        pub in_msg_fwd_fee: u64,
-        pub storage_fee: u64,
-        pub gas_fee: u64,
-        pub out_msgs_fwd_fee: u64,
-        pub total_account_fees: u64,
-        pub total_output: u64,
-    }
-
     pub(crate) fn call_executor(account: Account, msg: Message, config: BlockchainConfig, timestamp: u32)
-        -> Result<Transaction>
+        -> Result<(Transaction, Cell)>
     {
         let mut acc_root = account.write_to_new_cell()?.into();
 
         let block_lt = 1_000_000;
         let lt = Arc::new(std::sync::atomic::AtomicU64::new(block_lt + 1));
         let executor = OrdinaryTransactionExecutor::new(config);
-        executor.execute(
+        let transaction = executor.execute(
             Some(&msg),
             &mut acc_root,
             timestamp,
@@ -167,7 +157,8 @@ pub mod executor {
                     Some(ExecutorError::NoFundsToImportMsg) => SdkError::NoFundsError.into(),
                     _ => err
                 }
-            })
+            })?;
+        Ok((transaction, acc_root))
     }
 }