Merge pull request #5354 from zajko/endpoint_call_in_journal

Execution journal entries on entry point calls

Author: zajko

Cargo.lock

@@ -18,7 +18,7 @@ All notable changes to this project will be documented in this file. The format
 
 ### Added
 
-- A VM1 contract version install (both new and upgrade) will now produce a native message to system-owned topics:
+- A contract version install (both new and upgrade) will now produce a native message to system-owned topics:
   - in case `addressable_entity` is turned off:
     - `contract_key` topic will receive string-formatted `Key::Hash` containing the address of the new `StoredValue::Contract` value
     - `package_key` topic will receive string-formatted `Key::Hash` containing the address of the new `StoredValue::ContractPackage` value
@@ -29,6 +29,23 @@ All notable changes to this project will be documented in this file. The format
     - `package_key` topic will receive string-formatted `Key::SmartContract` containing the address of the new `SmartContract::Package` value
     - `bytecode_key` topic will receive string-formatted `Key::ByteCode` containing the address of the new `StoredValue::ByteCode` value
     - `contract_version` topic will receive a string containing the major contract and minor installed contract version (for example "2.1")
+- Calling wasm adds additional execution journal entries. For each session execution there will be a corresponding pair of TransformKindV2::EntryPointCalled and TransformKindV2::Ret written:
+   - For session bytes:
+      - the key under which both transforms will be stored is the Key::Account that initiated the transaction.
+      - The `Option<HashAddr>` of `EntryPointCalled` will be `None`
+      - The `String` of `EntryPointCalled` will be `"call"` (the default function name we expect of session wasm)
+      - The `Ret` will either be `RetValue::Unit` or `RetValue::CLValue` depending on wether or not the code called `casper_return`.
+   - If a session call calls a stored contracts entrypoint:
+      - the key under which both transforms will be stored is the Key::Account that initiated the transaction.
+      - The `Option<HashAddr>` of `EntryPointCalled` will be `Some(<called_contract_hash>)`
+      - The `String` of `EntryPointCalled` will be the name of the called entrypoint
+      - The `Ret` will either be `RetValue::Unit` or `RetValue::CLValue` depending on wether or not the code called `casper_return`.
+   - If a stored contract calls another stored contract:
+      - the key under which both transforms will be stored is the key of the contract which is executing the call.
+      - The `Option<HashAddr>` of `EntryPointCalled` will be `Some(<called_contract_hash>)`
+      - The `String` of `EntryPointCalled` will be the name of the called entrypoint
+      - The `Ret` will either be `RetValue::Unit` or `RetValue::CLValue` depending on wether or not the code called `casper_return`.
+    - the above also applies to `payment` bytecode if supplied
 
 ## 8.0.0
 

execution_engine/CHANGELOG.md

@@ -718,13 +718,13 @@ where
                 self.host_buffer = bytesrepr::deserialize_from_slice(buf).ok();
 
                 // Emit Ret transform to the execution journal
-                if let Some(cl_value) = &self.host_buffer {
-                    let key = self.context.get_context_key();
-                    self.context
-                        .state()
-                        .borrow_mut()
-                        .ret(key, RetValue::CLValue(cl_value.clone()));
-                }
+                let ret_val = if let Some(cl_value) = &self.host_buffer {
+                    RetValue::CLValue(cl_value.clone())
+                } else {
+                    RetValue::Unit
+                };
+                let key = self.context.get_context_key();
+                self.context.state().borrow_mut().ret(key, ret_val);
 
                 let urefs = match &self.host_buffer {
                     Some(buf) => utils::extract_urefs(buf),
@@ -1455,6 +1455,11 @@ where
         let protocol_version = self.context.protocol_version();
         let engine_config = self.context.engine_config();
         let wasm_config = engine_config.wasm_config();
+        self.context.state().borrow_mut().entry_point_called(
+            self.context.get_context_key(),
+            None,
+            DEFAULT_ENTRY_POINT_NAME.to_string(),
+        );
         #[cfg(feature = "test-support")]
         let max_stack_height = wasm_config.v1().max_stack_height();
         let module = preprocess(*wasm_config, module_bytes)?;
@@ -1483,6 +1488,10 @@ where
             // returned the unit type `()` as per Rust functions which don't specify a
             // return value.
             Ok(_) => {
+                self.context
+                    .state()
+                    .borrow_mut()
+                    .ret(self.context.get_context_key(), RetValue::Unit);
                 return Ok(self.take_host_buffer().unwrap_or(CLValue::from_t(())?));
             }
         };
@@ -1892,6 +1901,12 @@ where
             }
         };
 
+        self.context.state().borrow_mut().entry_point_called(
+            self.context.get_context_key(),
+            Some(entity_addr.value()),
+            entry_point_name.to_string(),
+        );
+
         if let EntityKind::Account(_) = footprint.entity_kind() {
             return Err(ExecError::InvalidContext);
         }
@@ -1916,6 +1931,11 @@ where
             }
         };
 
+        // if session the caller's context
+        // else the called contract's context
+        let context_entity_key =
+            self.get_context_key_for_contract_call(entity_addr, entry_point)?;
+
         let entry_point_type = entry_point.entry_point_type();
 
         if self.context.engine_config().enable_entity && entry_point_type.is_invalid_context() {
@@ -1971,11 +1991,6 @@ where
             return Err(ExecError::DisabledEntity(entity_hash));
         }
 
-        // if session the caller's context
-        // else the called contract's context
-        let context_entity_key =
-            self.get_context_key_for_contract_call(entity_addr, entry_point)?;
-
         let context_entity_hash = context_entity_key
             .into_entity_hash_addr()
             .ok_or(ExecError::UnexpectedKeyVariant(context_entity_key))?;
@@ -2199,7 +2214,6 @@ where
             .set_emit_message_cost(runtime.context.emit_message_cost());
         let transfers = self.context.transfers_mut();
         runtime.context.transfers().clone_into(transfers);
-
         match result {
             Ok(_) => {
                 // If `Ok` and the `host_buffer` is `None`, the contract's execution succeeded but
@@ -2215,6 +2229,8 @@ where
                 }
                 self.context
                     .set_remaining_spending_limit(runtime.context.remaining_spending_limit());
+                let key = self.context.get_context_key();
+                self.context.state().borrow_mut().ret(key, RetValue::Unit);
                 Ok(runtime.take_host_buffer().unwrap_or(CLValue::from_t(())?))
             }
             Err(error) => {

execution_engine/src/runtime/mod.rs

@@ -223,6 +223,24 @@ impl ExecuteRequestBuilder {
         )
     }
 
+    /// Returns an [`ExecuteRequest`] derived from a deploy with sessiond and payment bytecode.
+    pub fn standard_and_payment(
+        account_hash: AccountHash,
+        session_file: &str,
+        session_args: RuntimeArgs,
+        payment_file: &str,
+        payment_args: RuntimeArgs,
+    ) -> Self {
+        Self::standard_and_payment_with_protocol_version(
+            account_hash,
+            session_file,
+            session_args,
+            payment_file,
+            payment_args,
+            DEFAULT_PROTOCOL_VERSION,
+        )
+    }
+
     /// Returns an [`ExecuteRequest`] derived from a deploy with standard dependencies.
     pub fn standard_with_protocol_version(
         account_hash: AccountHash,
@@ -241,6 +259,24 @@ impl ExecuteRequestBuilder {
         Self::from_deploy_item_for_protocol_version(&deploy_item, protocol_version)
     }
 
+    /// Returns an [`ExecuteRequest`] derived from a deploy with standard dependencies.
+    pub fn standard_and_payment_with_protocol_version(
+        account_hash: AccountHash,
+        session_file: &str,
+        session_args: RuntimeArgs,
+        payment_file: &str,
+        payment_args: RuntimeArgs,
+        protocol_version: ProtocolVersion,
+    ) -> Self {
+        let deploy_item = DeployItemBuilder::new()
+            .with_address(account_hash)
+            .with_session_code(session_file, session_args)
+            .with_payment_code(payment_file, payment_args)
+            .with_authorization_keys(&[account_hash])
+            .build();
+        Self::from_deploy_item_for_protocol_version(&deploy_item, protocol_version)
+    }
+
     /// Returns an [`ExecuteRequest`] derived from a deploy with session module bytes.
     pub fn module_bytes(
         account_hash: AccountHash,