delegate_dependency api calls

CHANGELOG.md

@@ -14,6 +14,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - [Linter] Publish the linting crates on crates.io - [#2060](https://github.com/paritytech/ink/pull/2060)
 - [E2E] Added `create_call_builder` for testing existing contracts - [#2075](https://github.com/paritytech/ink/pull/2075)
 - `call_v2` cross-contract calls with additional limit parameters - [#2077](https://github.com/paritytech/ink/pull/2077)
+- `delegate_dependency` api calls - [#2076](https://github.com/paritytech/ink/pull/2076)
 
 ### Changed
 - `Mapping`: Reflect all possible failure cases in comments ‒ [#2079](https://github.com/paritytech/ink/pull/2079)

crates/e2e/src/backend.rs

@@ -16,6 +16,7 @@ use super::Keypair;
 use crate::{
     backend_calls::{
         InstantiateBuilder,
+        RemoveCodeBuilder,
         UploadBuilder,
     },
     builders::CreateBuilderPartial,
@@ -159,6 +160,28 @@ pub trait ContractsBackend<E: Environment> {
         UploadBuilder::new(self, contract_name, caller)
     }
 
+    /// Start building a remove code call.
+    /// # Example
+    ///
+    /// ```ignore
+    /// let contract = client
+    ///     .remove_code(&ink_e2e::alice(), code_hash)
+    ///     // Submit the call for on-chain execution.
+    ///     .submit()
+    ///     .await
+    ///     .expect("upload failed");
+    /// ```
+    fn remove_code<'a>(
+        &'a mut self,
+        caller: &'a Keypair,
+        code_hash: E::Hash,
+    ) -> RemoveCodeBuilder<E, Self>
+    where
+        Self: Sized + BuilderClient<E>,
+    {
+        RemoveCodeBuilder::new(self, caller, code_hash)
+    }
+
     /// Start building a call using a builder pattern.
     ///
     /// # Example
@@ -193,7 +216,7 @@ pub trait ContractsBackend<E: Environment> {
 
 #[async_trait]
 pub trait BuilderClient<E: Environment>: ContractsBackend<E> {
-    /// Executes a bare `call` for the contract at `account_id`. This function does
+    /// Executes a bare `call` for the contract at `account_id`. This function does not
     /// perform a dry-run, and user is expected to provide the gas limit.
     ///
     /// Use it when you want to have a more precise control over submitting extrinsic.
@@ -239,6 +262,13 @@ pub trait BuilderClient<E: Environment>: ContractsBackend<E> {
         storage_deposit_limit: Option<E::Balance>,
     ) -> Result<UploadResult<E, Self::EventLog>, Self::Error>;
 
+    /// Removes the code of the contract at `code_hash`.
+    async fn bare_remove_code(
+        &mut self,
+        caller: &Keypair,
+        code_hash: E::Hash,
+    ) -> Result<Self::EventLog, Self::Error>;
+
     /// Bare instantiate call. This function does not perform a dry-run,
     /// and user is expected to provide the gas limit.
     ///

crates/e2e/src/backend_calls.rs

@@ -400,6 +400,37 @@ where
     }
 }
 
+/// Allows to build an end-to-end remove code call using a builder pattern.
+pub struct RemoveCodeBuilder<'a, E, B>
+where
+    E: Environment,
+    B: BuilderClient<E>,
+{
+    client: &'a mut B,
+    caller: &'a Keypair,
+    code_hash: E::Hash,
+}
+
+impl<'a, E, B> RemoveCodeBuilder<'a, E, B>
+where
+    E: Environment,
+    B: BuilderClient<E>,
+{
+    /// Initialize a remove code builder with essential values.
+    pub fn new(client: &'a mut B, caller: &'a Keypair, code_hash: E::Hash) -> Self {
+        Self {
+            client,
+            caller,
+            code_hash,
+        }
+    }
+
+    /// Submit the remove code extrinsic.
+    pub async fn submit(&mut self) -> Result<B::EventLog, B::Error> {
+        B::bare_remove_code(self.client, self.caller, self.code_hash).await
+    }
+}
+
 fn calculate_weight(
     mut proof_size: u64,
     mut ref_time: u64,

crates/e2e/src/drink_client.rs

@@ -208,7 +208,7 @@ where
 #[async_trait]
 impl<
         AccountId: Clone + Send + Sync + From<[u8; 32]> + AsRef<[u8; 32]>,
-        Hash: Copy + From<[u8; 32]>,
+        Hash: Copy + Send + From<[u8; 32]>,
         Config: SandboxConfig,
         E: Environment<
                 AccountId = AccountId,
@@ -341,6 +341,14 @@ where
         })
     }
 
+    async fn bare_remove_code(
+        &mut self,
+        _caller: &Keypair,
+        _code_hash: E::Hash,
+    ) -> Result<Self::EventLog, Self::Error> {
+        unimplemented!("drink! sandbox does not yet support remove_code")
+    }
+
     async fn bare_call<Args: Sync + Encode + Clone, RetType: Send + Decode>(
         &mut self,
         caller: &Keypair,
@@ -420,7 +428,7 @@ where
 
 impl<
         AccountId: Clone + Send + Sync + From<[u8; 32]> + AsRef<[u8; 32]>,
-        Hash: Copy + From<[u8; 32]>,
+        Hash: Copy + Send + From<[u8; 32]>,
         Config: SandboxConfig,
         E: Environment<
                 AccountId = AccountId,

crates/e2e/src/error.rs

@@ -44,6 +44,9 @@ pub enum Error<DispatchError: fmt::Debug + fmt::Display> {
     /// The `call` extrinsic failed.
     #[error("Call extrinsic error: {0}")]
     CallExtrinsic(DispatchError),
+    /// The `remove_code` extrinsic failed.
+    #[error("Remove code extrinsic error: {0}")]
+    RemoveCodeExtrinsic(DispatchError),
     /// Error fetching account balance.
     #[error("Fetching account Balance error: {0}")]
     Balance(String),

crates/e2e/src/subxt_client.rs

@@ -468,7 +468,7 @@ where
     E::AccountId: Debug + Send + Sync,
     E::Balance:
         Clone + Debug + Send + Sync + From<u128> + scale::HasCompact + serde::Serialize,
-    E::Hash: Debug + Send + scale::Encode,
+    E::Hash: Debug + Send + Sync + scale::Encode,
 {
     async fn bare_instantiate<Contract: Clone, Args: Send + Sync + Encode + Clone, R>(
         &mut self,
@@ -536,6 +536,30 @@ where
         Ok(ret)
     }
 
+    async fn bare_remove_code(
+        &mut self,
+        caller: &Keypair,
+        code_hash: E::Hash,
+    ) -> Result<Self::EventLog, Self::Error> {
+        let tx_events = self.api.remove_code(caller, code_hash).await;
+
+        for evt in tx_events.iter() {
+            let evt = evt.unwrap_or_else(|err| {
+                panic!("unable to unwrap event: {err:?}");
+            });
+
+            if is_extrinsic_failed_event(&evt) {
+                let metadata = self.api.client.metadata();
+                let dispatch_error =
+                    DispatchError::decode_from(evt.field_bytes(), metadata)
+                        .map_err(|e| Error::Decoding(e.to_string()))?;
+                return Err(Error::RemoveCodeExtrinsic(dispatch_error))
+            }
+        }
+
+        Ok(tx_events)
+    }
+
     async fn bare_call<Args: Sync + Encode + Clone, RetType: Send + Decode>(
         &mut self,
         caller: &Keypair,
@@ -571,7 +595,7 @@ where
             if is_extrinsic_failed_event(&evt) {
                 let metadata = self.api.client.metadata();
                 let dispatch_error =
-                    subxt::error::DispatchError::decode_from(evt.field_bytes(), metadata)
+                    DispatchError::decode_from(evt.field_bytes(), metadata)
                         .map_err(|e| Error::Decoding(e.to_string()))?;
                 log_error(&format!("extrinsic for call failed: {dispatch_error}"));
                 return Err(Error::CallExtrinsic(dispatch_error))
@@ -660,13 +684,14 @@ where
     C::Address: From<sr25519::PublicKey>,
     C::Signature: From<sr25519::Signature>,
     C::Address: Send + Sync,
-    <<C as subxt::Config>::ExtrinsicParams as subxt::config::ExtrinsicParams<C>>::OtherParams: Default + Send + Sync,
+    <<C as subxt::Config>::ExtrinsicParams as ExtrinsicParams<C>>::OtherParams:
+        Default + Send + Sync,
 
     E: Environment,
     E::AccountId: Debug + Send + Sync,
     E::Balance:
         Clone + Debug + Send + Sync + From<u128> + scale::HasCompact + serde::Serialize,
-    E::Hash: Debug + Send + scale::Encode,
+    E::Hash: Debug + Send + Sync + scale::Encode,
 {
 }
 

crates/e2e/src/xts.rs

@@ -144,6 +144,13 @@ pub enum Determinism {
     Relaxed,
 }
 
+/// A raw call to `pallet-contracts`'s `remove_code`.
+#[derive(Debug, scale::Encode, scale::Decode, scale_encode::EncodeAsType)]
+#[encode_as_type(trait_bounds = "", crate_path = "subxt::ext::scale_encode")]
+pub struct RemoveCode<E: Environment> {
+    code_hash: E::Hash,
+}
+
 /// A raw call to `pallet-contracts`'s `upload`.
 #[derive(Debug, scale::Encode, scale::Decode, scale_encode::EncodeAsType)]
 #[encode_as_type(trait_bounds = "", crate_path = "subxt::ext::scale_encode")]
@@ -471,6 +478,25 @@ where
         self.submit_extrinsic(&call, signer).await
     }
 
+    /// Submits an extrinsic to remove the code at the given hash.
+    ///
+    /// Returns when the transaction is included in a block. The return value
+    /// contains all events that are associated with this transaction.
+    pub async fn remove_code(
+        &self,
+        signer: &Keypair,
+        code_hash: E::Hash,
+    ) -> ExtrinsicEvents<C> {
+        let call = subxt::tx::Payload::new(
+            "Contracts",
+            "remove_code",
+            RemoveCode::<E> { code_hash },
+        )
+        .unvalidated();
+
+        self.submit_extrinsic(&call, signer).await
+    }
+
     /// Dry runs a call of the contract at `contract` with the given parameters.
     pub async fn call_dry_run(
         &self,

crates/env/src/api.rs

@@ -823,3 +823,42 @@ where
         TypedEnvBackend::call_runtime::<E, _>(instance, call)
     })
 }
+
+/// Adds a new delegate dependency to the contract.
+///
+/// This guarantees that the code of the dependency cannot be removed without first
+/// calling [`remove_delegate_dependency`]. It charges a fraction of the code
+/// deposit.
+///
+/// # Errors
+///
+/// - If the supplied `code_hash` cannot be found on-chain.
+/// - If the `code_hash` is the same as the calling contract.
+/// - If the maximum number of delegate dependencies is reached
+/// - If the delegate dependency already exists.
+pub fn add_delegate_dependency<E>(code_hash: &E::Hash)
+where
+    E: Environment,
+{
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        instance.add_delegate_dependency::<E>(code_hash)
+    })
+}
+
+/// Removes the delegate dependency from the contract.
+///
+/// This removes the lock and refunds the deposit from the call to
+/// [`add_delegate_dependency`]. The code of the dependency can be removed if the
+/// reference count for the code hash is now zero.
+///
+/// # Errors
+///
+/// - If the delegate dependency does not exist.
+pub fn remove_delegate_dependency<E>(code_hash: &E::Hash)
+where
+    E: Environment,
+{
+    <EnvInstance as OnInstance>::on_instance(|instance| {
+        instance.remove_delegate_dependency::<E>(code_hash)
+    })
+}

crates/env/src/backend.rs

@@ -418,4 +418,24 @@ pub trait TypedEnvBackend: EnvBackend {
     where
         E: Environment,
         Call: scale::Encode;
+
+    /// Adds a new delegate dependency to the contract.
+    ///
+    /// # Note
+    ///
+    /// For more details visit:
+    /// [`add_delegate_dependency`][`crate::add_delegate_dependency`]
+    fn add_delegate_dependency<E>(&mut self, code_hash: &E::Hash)
+    where
+        E: Environment;
+
+    /// Removes the delegate dependency from the contract.
+    ///
+    /// # Note
+    ///
+    /// For more details visit:
+    /// [`remove_delegate_dependency`][`crate::remove_delegate_dependency`]
+    fn remove_delegate_dependency<E>(&mut self, code_hash: &E::Hash)
+    where
+        E: Environment;
 }

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

@@ -560,4 +560,18 @@ impl TypedEnvBackend for EnvInstance {
     {
         unimplemented!("off-chain environment does not support `call_runtime`")
     }
+
+    fn add_delegate_dependency<E>(&mut self, _code_hash: &E::Hash)
+    where
+        E: Environment,
+    {
+        unimplemented!("off-chain environment does not support delegate dependencies")
+    }
+
+    fn remove_delegate_dependency<E>(&mut self, _code_hash: &E::Hash)
+    where
+        E: Environment,
+    {
+        unimplemented!("off-chain environment does not support delegate dependencies")
+    }
 }

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

@@ -660,4 +660,24 @@ impl TypedEnvBackend for EnvInstance {
         let enc_call = scope.take_encoded(call);
         ext::call_runtime(enc_call).map_err(Into::into)
     }
+
+    fn add_delegate_dependency<E>(&mut self, code_hash: &E::Hash)
+    where
+        E: Environment,
+    {
+        let mut scope = self.scoped_buffer();
+        let enc_code_hash = scope.take_encoded(code_hash);
+        #[allow(deprecated)]
+        ext::add_delegate_dependency(enc_code_hash)
+    }
+
+    fn remove_delegate_dependency<E>(&mut self, code_hash: &E::Hash)
+    where
+        E: Environment,
+    {
+        let mut scope = self.scoped_buffer();
+        let enc_code_hash = scope.take_encoded(code_hash);
+        #[allow(deprecated)]
+        ext::remove_delegate_dependency(enc_code_hash)
+    }
 }