Use pallet-contracts-uapi

.github/workflows/ci.yml

@@ -39,7 +39,7 @@ env:
   # We plan to fully support RISC-V as a bytecode for contracts soon.
   # RISC-V does not have a standard library in contrast to Wasm. Compiling against
   # this target also makes sure that we don't pull in `std` by accident (through dependencies).
-  # RISC-V is a modular archtitecture. We might switch to a different flavor with more features
+  # RISC-V is a modular architecture. We might switch to a different flavor with more features
   # later. For example, `riscv32imc-unknown-none-elf`.
   RISCV_TARGET:                    riscv32i-unknown-none-elf
 

ARCHITECTURE.md

@@ -153,8 +153,8 @@ If you look at the implementations you'll see a common pattern of
   for contract developers.
 
 ### The pallet API
-The function signature of the `pallet-contracts` API functions is defined in
-[`ink_env/src/engine/on_chain/ext.rs`](https://github.com/paritytech/ink/blob/master/crates/env/src/engine/on_chain/ext.rs).
+Signatures of host API functions are defined in
+[`pallet-contracts-uapi`](https://github.com/paritytech/polkadot-sdk/blob/master/substrate/frame/contracts/uapi/src/host/wasm32.rs).
 You'll see that we import different versions of API functions, something
 like the following excerpt:
 

Cargo.toml

@@ -84,6 +84,9 @@ const_env = { version = "0.1"}
 
 # Substrate dependencies
 pallet-contracts-primitives = { version = "26.0.0", default-features = false }
+# TODO update once released
+# pallet-contracts-uapi = { path = "/Users/pg/github/polkadot-sdk/substrate/frame/contracts/uapi",  default-features = false }
+pallet-contracts-uapi = { git = "https://github.com/paritytech/polkadot-sdk.git", rev="e79922fde334a46f11a3bb7723a1850e97271991", default-features = false }
 sp-core = { version = "23.0.0", default-features = false }
 sp-keyring = { version = "26.0.0", default-features = false }
 sp-runtime = { version = "26.0.0", default-features = false }

crates/engine/Cargo.toml

@@ -17,6 +17,7 @@ include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE"]
 [dependencies]
 ink_primitives = { workspace = true }
 scale = { workspace = true }
+pallet-contracts-uapi = { workspace = true }
 derive_more = { workspace = true, features = ["from", "display"] }
 
 sha2 = { workspace = true }

crates/engine/src/ext.rs

@@ -31,85 +31,10 @@ use crate::{
         BlockTimestamp,
     },
 };
+pub use pallet_contracts_uapi::ReturnErrorCode as Error;
 use scale::Encode;
 use std::panic::panic_any;
 
-macro_rules! define_error_codes {
-    (
-        $(
-            $( #[$attr:meta] )*
-            $name:ident = $discr:literal,
-        )*
-    ) => {
-        /// Every error that can be returned to a contract when it calls any of the host functions.
-        #[cfg_attr(test, derive(PartialEq, Eq))]
-        #[derive(Debug)]
-        #[repr(u32)]
-        pub enum Error {
-            $(
-                $( #[$attr] )*
-                $name = $discr,
-            )*
-            /// Returns if an unknown error was received from the host module.
-            Unknown,
-        }
-
-        impl From<ReturnCode> for Result<(), Error> {
-            #[inline]
-            fn from(return_code: ReturnCode) -> Self {
-                match return_code.0 {
-                    0 => Ok(()),
-                    $(
-                        $discr => Err(Error::$name),
-                    )*
-                    _ => Err(Error::Unknown),
-                }
-            }
-        }
-    };
-}
-define_error_codes! {
-    /// The called function trapped and has its state changes reverted.
-    /// In this case no output buffer is returned.
-    /// Can only be returned from `call` and `instantiate`.
-    CalleeTrapped = 1,
-    /// The called function ran to completion but decided to revert its state.
-    /// An output buffer is returned when one was supplied.
-    /// Can only be returned from `call` and `instantiate`.
-    CalleeReverted = 2,
-    /// The passed key does not exist in storage.
-    KeyNotFound = 3,
-    /// Deprecated and no longer returned: There is only the minimum balance.
-    _BelowSubsistenceThreshold = 4,
-    /// Transfer failed for other not further specified reason. Most probably
-    /// reserved or locked balance of the sender that was preventing the transfer.
-    TransferFailed = 5,
-    /// Deprecated and no longer returned: Endowment is no longer required.
-    _EndowmentTooLow = 6,
-    /// No code could be found at the supplied code hash.
-    CodeNotFound = 7,
-    /// The account that was called is no contract.
-    NotCallable = 8,
-    /// The call to `debug_message` had no effect because debug message
-    /// recording was disabled.
-    LoggingDisabled = 9,
-    /// ECDSA public key recovery failed. Most probably wrong recovery id or signature.
-    EcdsaRecoveryFailed = 11,
-    /// sr25519 signature verification failed. This may be because of an invalid public key, invalid message or invalid signature.
-    Sr25519VerifyFailed = 12,
-}
-
-/// The raw return code returned by the host side.
-#[repr(transparent)]
-pub struct ReturnCode(u32);
-
-impl ReturnCode {
-    /// Returns the raw underlying `u32` representation.
-    pub fn into_u32(self) -> u32 {
-        self.0
-    }
-}
-
 /// The off-chain engine.
 pub struct Engine {
     /// The environment database.

crates/env/Cargo.toml

@@ -20,6 +20,7 @@ ink_allocator = { workspace = true }
 ink_storage_traits = { workspace = true }
 ink_prelude = { workspace = true }
 ink_primitives = { workspace = true }
+pallet-contracts-uapi = { workspace = true }
 
 scale = { workspace = true }
 derive_more = { workspace = true, features = ["from", "display"] }

crates/env/src/api.rs

@@ -17,7 +17,6 @@
 use crate::{
     backend::{
         EnvBackend,
-        ReturnFlags,
         TypedEnvBackend,
     },
     call::{
@@ -42,6 +41,7 @@ use crate::{
     Result,
 };
 use ink_storage_traits::Storable;
+use pallet_contracts_uapi::ReturnFlags;
 
 /// Returns the address of the caller of the executed contract.
 ///

crates/env/src/backend.rs

@@ -30,142 +30,7 @@ use crate::{
     Result,
 };
 use ink_storage_traits::Storable;
-
-/// The flags to indicate further information about the end of a contract execution.
-#[derive(Default)]
-pub struct ReturnFlags {
-    value: u32,
-}
-
-impl ReturnFlags {
-    /// Initialize [`ReturnFlags`] with the reverted flag.
-    pub fn new_with_reverted(has_reverted: bool) -> Self {
-        Self::default().set_reverted(has_reverted)
-    }
-
-    /// Sets the bit to indicate that the execution is going to be reverted.
-    #[must_use]
-    pub fn set_reverted(mut self, has_reverted: bool) -> Self {
-        match has_reverted {
-            true => self.value |= has_reverted as u32,
-            false => self.value &= !has_reverted as u32,
-        }
-        self
-    }
-
-    /// Returns the underlying `u32` representation.
-    #[cfg(not(feature = "std"))]
-    pub(crate) fn into_u32(self) -> u32 {
-        self.value
-    }
-}
-
-/// The flags used to change the behavior of a contract call.
-#[must_use]
-#[derive(Copy, Clone, Debug, Default)]
-pub struct CallFlags {
-    forward_input: bool,
-    clone_input: bool,
-    tail_call: bool,
-    allow_reentry: bool,
-}
-
-impl CallFlags {
-    /// Forwards the input for the current function to the callee.
-    ///
-    /// # Note
-    ///
-    /// A forwarding call will consume the current contracts input. Any attempt to
-    /// access the input after this call returns (e.g. by trying another forwarding call)
-    /// will lead to a contract revert.
-    /// Consider using [`Self::set_clone_input`] in order to preserve the input.
-    pub const fn set_forward_input(mut self, forward_input: bool) -> Self {
-        self.forward_input = forward_input;
-        self
-    }
-
-    /// Identical to [`Self::set_forward_input`] but without consuming the input.
-    ///
-    /// This adds some additional weight costs to the call.
-    ///
-    /// # Note
-    ///
-    /// This implies [`Self::set_forward_input`] and takes precedence when both are set.
-    pub const fn set_clone_input(mut self, clone_input: bool) -> Self {
-        self.clone_input = clone_input;
-        self
-    }
-
-    /// Do not return from the call but rather return the result of the callee to the
-    /// callers caller.
-    ///
-    /// # Note
-    ///
-    /// This makes the current contract completely transparent to its caller by replacing
-    /// this contracts potential output with the callee ones. Any code after the contract
-    /// calls has been invoked can be safely considered unreachable.
-    pub const fn set_tail_call(mut self, tail_call: bool) -> Self {
-        self.tail_call = tail_call;
-        self
-    }
-
-    /// Allow the callee to reenter into the current contract.
-    ///
-    /// Without this flag any reentrancy into the current contract that originates from
-    /// the callee (or any of its callees) is denied. This includes the first callee:
-    /// You cannot call into yourself with this flag set.
-    pub const fn set_allow_reentry(mut self, allow_reentry: bool) -> Self {
-        self.allow_reentry = allow_reentry;
-        self
-    }
-
-    /// Returns the underlying `u32` representation of the call flags.
-    ///
-    /// This value is used to forward the call flag information to the
-    /// `contracts` pallet.
-    pub(crate) const fn into_u32(self) -> u32 {
-        self.forward_input as u32
-            | ((self.clone_input as u32) << 1)
-            | ((self.tail_call as u32) << 2)
-            | ((self.allow_reentry as u32) << 3)
-    }
-
-    /// Returns `true` if input forwarding is set.
-    ///
-    /// # Note
-    ///
-    /// See [`Self::set_forward_input`] for more information.
-    pub const fn forward_input(&self) -> bool {
-        self.forward_input
-    }
-
-    /// Returns `true` if input cloning is set.
-    ///
-    /// # Note
-    ///
-    /// See [`Self::set_clone_input`] for more information.
-    pub const fn clone_input(&self) -> bool {
-        self.clone_input
-    }
-
-    /// Returns `true` if the tail call property is set.
-    ///
-    /// # Note
-    ///
-    /// See [`Self::set_tail_call`] for more information.
-    pub const fn tail_call(&self) -> bool {
-        self.tail_call
-    }
-
-    /// Returns `true` if call reentry is allowed.
-    ///
-    /// # Note
-    ///
-    /// See [`Self::set_allow_reentry`] for more information.
-    pub const fn allow_reentry(&self) -> bool {
-        self.allow_reentry
-    }
-}
+pub use pallet_contracts_uapi::ReturnFlags;
 
 /// Environmental contract functionality that does not require `Environment`.
 pub trait EnvBackend {