Implement .terminate_contract using precompile

Author: cmichi

crates/engine/src/ext.rs

@@ -191,7 +191,7 @@ impl Engine {
     /// This function never returns. Either the termination was successful and the
     /// execution of the destroyed contract is halted. Or it failed during the
     /// termination which is considered fatal.
-    pub fn terminate(&mut self, beneficiary: Address) -> ! {
+    pub fn terminate(&mut self, beneficiary: Address) -> Result<(), Error> {
         // Send the remaining balance to the beneficiary
         let contract = self.get_callee();
         let all = self
@@ -201,11 +201,7 @@ impl Engine {
         self.transfer(beneficiary, value)
             .unwrap_or_else(|err| panic!("transfer did not work: {err:?}"));
 
-        // Encode the result of the termination and panic with it.
-        // This enables testing for the proper result and makes sure this
-        // method returns `Never`.
-        let res = (all, beneficiary);
-        panic_any(scale::Encode::encode(&res));
+        Ok(())
     }
 
     /// Returns the address of the caller.

crates/env/src/api.rs

@@ -436,8 +436,7 @@ where
 /// This function never returns. Either the termination was successful and the
 /// execution of the destroyed contract is halted. Or it failed during the termination
 /// which is considered fatal and results in a trap and rollback.
-#[cfg(feature = "unstable-hostfn")]
-pub fn terminate_contract(beneficiary: Address) -> ! {
+pub fn terminate_contract(beneficiary: Address) -> Result<()> {
     <EnvInstance as OnInstance>::on_instance(|instance| {
         TypedEnvBackend::terminate_contract(instance, beneficiary)
     })

crates/env/src/backend.rs

@@ -368,8 +368,7 @@ pub trait TypedEnvBackend: EnvBackend {
     /// # Note
     ///
     /// For more details visit: [`terminate_contract`][`crate::terminate_contract`]
-    #[cfg(feature = "unstable-hostfn")]
-    fn terminate_contract(&mut self, beneficiary: Address) -> !;
+    fn terminate_contract(&mut self, beneficiary: Address) -> Result<()>;
 
     /// Transfers value from the contract to the destination account ID.
     ///

crates/env/src/engine/off_chain/impls.rs

@@ -747,9 +747,8 @@ impl TypedEnvBackend for EnvInstance {
         ))))
     }
 
-    #[cfg(feature = "unstable-hostfn")]
-    fn terminate_contract(&mut self, beneficiary: Address) -> ! {
-        self.engine.terminate(beneficiary)
+    fn terminate_contract(&mut self, beneficiary: Address) -> Result<()> {
+        self.engine.terminate(beneficiary).map_err(Into::into)
     }
 
     fn transfer<E>(&mut self, destination: Address, value: U256) -> Result<()>

crates/env/src/engine/on_chain/pallet_revive.rs

@@ -1213,14 +1213,29 @@ impl TypedEnvBackend for EnvInstance {
         )
     }
 
-    #[cfg(feature = "unstable-hostfn")]
-    fn terminate_contract(&mut self, beneficiary: Address) -> ! {
-        let buffer: &mut [u8; 20] = self.scoped_buffer().take_encoded(&beneficiary)
-            [0..20]
-            .as_mut()
-            .try_into()
-            .unwrap();
-        ext::terminate(buffer);
+    fn terminate_contract(&mut self, beneficiary: Address) -> Result<()> {
+        let mut scope = self.scoped_buffer();
+        let addr = beneficiary.as_fixed_bytes();
+
+        const ADDR: [u8; 20] =
+            hex_literal::hex!("0000000000000000000000000000000000000900");
+
+        let mut input = [0u8; 32 + 4];
+        let sel = const { solidity_selector("terminate(address)") };
+        input[..4].copy_from_slice(&sel[..4]);
+        input[16..36].copy_from_slice(&addr[..]);
+
+        let _ = ext::call(
+            CallFlags::empty(),
+            &ADDR,
+            u64::MAX,       // `ref_time` to devote for execution. `u64::MAX` = all
+            u64::MAX,       // `proof_size` to devote for execution. `u64::MAX` = all
+            &[u8::MAX; 32], // No deposit limit.
+            &U256::zero().to_little_endian(), // Value transferred to the contract.
+            &input[..],
+            None,
+        );
+        Ok(())
     }
 
     fn transfer<E>(&mut self, destination: Address, value: U256) -> Result<()>

crates/ink/src/env_access.rs

@@ -762,8 +762,7 @@ where
     /// # Note
     ///
     /// For more details visit: [`ink_env::terminate_contract`]
-    #[cfg(feature = "unstable-hostfn")]
-    pub fn terminate_contract(self, beneficiary: Address) -> ! {
+    pub fn terminate_contract(self, beneficiary: Address) -> Result<()> {
         ink_env::terminate_contract(beneficiary)
     }
 

integration-tests/public/contract-terminate/Cargo.toml

@@ -6,7 +6,7 @@ edition = "2024"
 publish = false
 
 [dependencies]
-ink = { path = "../../../crates/ink", default-features = false, features = ["unstable-hostfn"] }
+ink = { path = "../../../crates/ink", default-features = false }
 
 [dev-dependencies]
 ink_e2e = { path = "../../../crates/e2e" }

integration-tests/public/contract-terminate/lib.rs

@@ -20,7 +20,14 @@ pub mod just_terminates {
         /// Terminates with the caller as beneficiary.
         #[ink(message)]
         pub fn terminate_me(&mut self) {
-            self.env().terminate_contract(self.env().caller());
+            self.env()
+                .terminate_contract(self.env().caller())
+                .expect("must succeed");
+        }
+
+        #[ink(message)]
+        pub fn get(&self) -> u64 {
+            13
         }
     }
 
@@ -77,17 +84,17 @@ pub mod just_terminates {
                 .await
                 .expect("terminate_me messages failed");
 
-            assert!(
-                call_res.return_data().is_empty(),
-                "Terminated contract never returns"
-            );
-
             // then
             assert!(call_res.contains_event("System", "KilledAccount"));
             assert!(call_res.contains_event("Balances", "Withdraw"));
-            // todo this event below no longer exists, but we could try getting
-            // info for the contract and asserting that it fails.
-            // assert!(call_res.contains_event("Revive", "Terminated"));
+
+            let get = call_builder.get();
+            let call_res = client
+                .call(&ink_e2e::alice(), &get)
+                .submit()
+                .await
+                .expect("get message failed");
+            assert!(call_res.dry_run.exec_result.result.unwrap().data.is_empty());
 
             Ok(())
         }