ic_utils/interfaces/management_canister/

builders.rs

//! Builder interfaces for some method calls of the management canister.

#[doc(inline)]
pub use super::attributes::{
    ComputeAllocation, FreezingThreshold, LogMemoryLimit, MemoryAllocation, ReservedCyclesLimit,
    WasmMemoryLimit,
};
use super::{ChunkHash, LogVisibility, ManagementCanister};
use crate::call::CallFuture;
use crate::{
    call::AsyncCall, canister::Argument, interfaces::management_canister::MgmtMethod, Canister,
};
use async_trait::async_trait;
use candid::{decode_args, utils::ArgumentEncoder, CandidType, Deserialize, Encode, Nat};
use futures_util::{
    future::ready,
    stream::{self, FuturesUnordered},
    FutureExt, Stream, StreamExt, TryStreamExt,
};
use ic_agent::{
    agent::{CallResponse, EffectiveId},
    export::Principal,
    AgentError,
};
pub use ic_management_canister_types::{
    CanisterInstallMode, CanisterSettings, EnvironmentVariable, InstallCodeArgs,
    SnapshotVisibility, UpgradeFlags, WasmMemoryPersistence,
};
use sha2::{Digest, Sha256};
use std::{
    collections::BTreeSet,
    convert::{From, TryInto},
    future::IntoFuture,
    pin::Pin,
};

/// Reject combining [`CreateCanisterBuilder::with_canister_settings`] /
/// [`UpdateSettingsBuilder::with_canister_settings`] with any individual settings
/// setter (`with_controller`, `with_compute_allocation`, …), which are currently
/// mutually exclusive.
fn reject_mixed_settings(has_individual_settings: bool) -> Result<(), AgentError> {
    if has_individual_settings {
        return Err(AgentError::MessageError(
            "`with_canister_settings` cannot be combined with the individual settings \
             setters (`with_controller`, `with_compute_allocation`, etc.)"
                .to_string(),
        ));
    }
    Ok(())
}

/// A builder for a `create_canister` call.
#[derive(Debug)]
pub struct CreateCanisterBuilder<'agent, 'canister: 'agent> {
    canister: &'canister Canister<'agent>,
    /// For most use cases, this is `effective_canister_id`, the call will create a canister on the same subnet of it.
    /// Subnet administrators can directly set effective_subnet_id and the canister will be created on the specified subnet.
    effective_id: EffectiveId,
    controllers: Option<Result<Vec<Principal>, AgentError>>,
    compute_allocation: Option<Result<ComputeAllocation, AgentError>>,
    memory_allocation: Option<Result<MemoryAllocation, AgentError>>,
    freezing_threshold: Option<Result<FreezingThreshold, AgentError>>,
    reserved_cycles_limit: Option<Result<ReservedCyclesLimit, AgentError>>,
    wasm_memory_limit: Option<Result<WasmMemoryLimit, AgentError>>,
    wasm_memory_threshold: Option<Result<WasmMemoryLimit, AgentError>>,
    log_visibility: Option<Result<LogVisibility, AgentError>>,
    log_memory_limit: Option<Result<LogMemoryLimit, AgentError>>,
    environment_variables: Option<Result<Vec<EnvironmentVariable>, AgentError>>,
    snapshot_visibility: Option<Result<SnapshotVisibility, AgentError>>,
    settings: Option<CanisterSettings>,
    is_provisional_create: bool,
    amount: Option<u128>,
    specified_id: Option<Principal>,
}

impl<'agent, 'canister: 'agent> CreateCanisterBuilder<'agent, 'canister> {
    /// Create an `CreateCanister` builder, which is also an `AsyncCall` implementation.
    pub fn builder(canister: &'canister Canister<'agent>) -> Self {
        Self {
            canister,
            effective_id: EffectiveId::Canister(Principal::management_canister()),
            controllers: None,
            compute_allocation: None,
            memory_allocation: None,
            freezing_threshold: None,
            reserved_cycles_limit: None,
            wasm_memory_limit: None,
            wasm_memory_threshold: None,
            log_visibility: None,
            log_memory_limit: None,
            environment_variables: None,
            snapshot_visibility: None,
            settings: None,
            is_provisional_create: false,
            amount: None,
            specified_id: None,
        }
    }

    /// Until developers can convert real ICP tokens to provision a new canister with cycles,
    /// the system provides the `provisional_create_canister_with_cycles` method.
    /// It behaves as `create_canister`, but initializes the canister’s balance with amount fresh cycles
    /// (using `MAX_CANISTER_BALANCE` if amount = null, else capping the balance at `MAX_CANISTER_BALANCE`).
    /// Cycles added to this call via `ic0.call_cycles_add` are returned to the caller.
    /// This method is only available in local development instances, and will be removed in the future.
    #[allow(clippy::wrong_self_convention)]
    pub fn as_provisional_create_with_amount(self, amount: Option<u128>) -> Self {
        Self {
            is_provisional_create: true,
            amount,
            ..self
        }
    }

    /// Specify the canister id.
    ///
    /// The effective canister id will also be set to the same value so that ic-ref can determine
    /// the target subnet of this request. The replica implementation ignores it.
    ///
    /// This overwrites the effective id previously set by [`Self::with_effective_canister_id`] or
    /// [`Self::with_effective_subnet_id`] (and is itself overwritten by any later call to those).
    /// Only the last call among the three takes effect.
    pub fn as_provisional_create_with_specified_id(self, specified_id: Principal) -> Self {
        Self {
            is_provisional_create: true,
            specified_id: Some(specified_id),
            effective_id: EffectiveId::Canister(specified_id),
            ..self
        }
    }

    /// Pass in an effective canister id for the update call.
    ///
    /// Boundary nodes use the effective {canister / subnet} id to route the request to the target subnet.
    ///
    /// This method, [`Self::with_effective_subnet_id`], and [`Self::as_provisional_create_with_specified_id`]
    /// all write to the same underlying field, so only the last call among them takes effect; earlier
    /// calls are silently shadowed.
    pub fn with_effective_canister_id<C, E>(self, effective_canister_id: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<Principal, Error = E>,
    {
        match effective_canister_id.try_into() {
            Ok(effective_canister_id) => Self {
                effective_id: EffectiveId::Canister(effective_canister_id),
                ..self
            },
            Err(_) => self,
        }
    }

    /// Pass in an effective subnet id for the update call.
    ///
    /// The constructed `create_canister` call is only valid if the caller has subnet administrator permissions.
    ///
    /// Boundary nodes use the effective {canister / subnet} id to route the request to the target subnet.
    ///
    /// This method, [`Self::with_effective_canister_id`], and [`Self::as_provisional_create_with_specified_id`]
    /// all write to the same underlying field, so only the last call among them takes effect; earlier
    /// calls are silently shadowed.
    pub fn with_effective_subnet_id<C, E>(self, effective_subnet_id: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<Principal, Error = E>,
    {
        match effective_subnet_id.try_into() {
            Ok(subnet_id) => Self {
                effective_id: EffectiveId::Subnet(subnet_id),
                ..self
            },
            Err(_) => self,
        }
    }

    /// Pass in a controller for the canister. Can be called multiple times to add multiple controllers.
    pub fn with_controller<C, E>(self, controller: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<Principal, Error = E>,
    {
        let controller_result = controller
            .try_into()
            .map_err(|e| AgentError::MessageError(format!("{e}")));
        let controllers = match (controller_result, self.controllers) {
            (_, Some(Err(sticky))) => Some(Err(sticky)),
            (Err(e), _) => Some(Err(e)),
            (Ok(controller), Some(Ok(mut controllers))) => {
                controllers.push(controller);
                Some(Ok(controllers))
            }
            (Ok(controller), None) => Some(Ok(vec![controller])),
        };
        Self {
            controllers,
            ..self
        }
    }

    /// Pass in a compute allocation value for the canister.
    pub fn with_compute_allocation<C, E>(self, compute_allocation: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<ComputeAllocation, Error = E>,
    {
        Self {
            compute_allocation: Some(
                compute_allocation
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a memory allocation value for the canister.
    pub fn with_memory_allocation<C, E>(self, memory_allocation: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<MemoryAllocation, Error = E>,
    {
        Self {
            memory_allocation: Some(
                memory_allocation
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a freezing threshold value for the canister.
    pub fn with_freezing_threshold<C, E>(self, freezing_threshold: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<FreezingThreshold, Error = E>,
    {
        Self {
            freezing_threshold: Some(
                freezing_threshold
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a reserved cycles limit value for the canister.
    pub fn with_reserved_cycles_limit<C, E>(self, limit: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<ReservedCyclesLimit, Error = E>,
    {
        Self {
            reserved_cycles_limit: Some(
                limit
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a Wasm memory limit value for the canister.
    pub fn with_wasm_memory_limit<C, E>(self, wasm_memory_limit: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<WasmMemoryLimit, Error = E>,
    {
        Self {
            wasm_memory_limit: Some(
                wasm_memory_limit
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a Wasm memory threshold value for the canister.
    pub fn with_wasm_memory_threshold<C, E>(self, wasm_memory_threshold: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<WasmMemoryLimit, Error = E>,
    {
        Self {
            wasm_memory_threshold: Some(
                wasm_memory_threshold
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a log memory limit value for the canister.
    pub fn with_log_memory_limit<C, E>(self, log_memory_limit: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<LogMemoryLimit, Error = E>,
    {
        Self {
            log_memory_limit: Some(
                log_memory_limit
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a log visibility setting for the canister.
    pub fn with_log_visibility<C, E>(self, log_visibility: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<LogVisibility, Error = E>,
    {
        Self {
            log_visibility: Some(
                log_visibility
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in environment variables for the canister.
    pub fn with_environment_variables<E, C>(self, environment_variables: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<Vec<EnvironmentVariable>, Error = E>,
    {
        Self {
            environment_variables: Some(
                environment_variables
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a snapshot visibility setting for the canister.
    pub fn with_snapshot_visibility<C, E>(self, snapshot_visibility: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<SnapshotVisibility, Error = E>,
    {
        Self {
            snapshot_visibility: Some(
                snapshot_visibility
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a complete [`CanisterSettings`] for the canister.
    ///
    /// This is a convenience for callers that already hold a `CanisterSettings`
    /// (e.g. decoded from a config or forwarded from another call) and do not
    /// want to decompose it into individual setters.
    ///
    /// It is currently **mutually exclusive** with the individual settings
    /// setters (`with_controller`, `with_compute_allocation`, …): building the
    /// call returns an error if this method is combined with any of them.
    pub fn with_canister_settings(self, settings: CanisterSettings) -> Self {
        Self {
            settings: Some(settings),
            ..self
        }
    }

    /// Create an [`AsyncCall`] implementation that, when called, will create a
    /// canister.
    ///
    /// Returns an error when the builder was configured with [`Self::with_effective_subnet_id`];
    /// the subnet-scoped routing requires direct dispatch via [`Self::call`] or
    /// [`Self::call_and_wait`] and is not expressible through the generic [`AsyncCall`] surface.
    pub fn build(self) -> Result<impl 'agent + AsyncCall<Value = (Principal,)>, AgentError> {
        let prepared = self.prepare()?;
        let effective_canister_id = match prepared.effective_id {
            EffectiveId::Canister(p) => p,
            EffectiveId::Subnet(_) => {
                return Err(AgentError::MessageError(
                    "CreateCanisterBuilder::build() does not support subnet routing; \
                     use call()/call_and_wait() instead."
                        .into(),
                ));
            }
        };
        Ok(prepared
            .canister
            .update(prepared.method)
            .with_arg_raw(prepared.arg_bytes)
            .with_effective_canister_id(effective_canister_id)
            .build()
            .map(|result: (CreateCanisterOut,)| (result.0.canister_id,)))
    }

    /// Make a call. This is equivalent to the [`AsyncCall::call`].
    pub async fn call(self) -> Result<CallResponse<(Principal,)>, AgentError> {
        match self.effective_id {
            EffectiveId::Canister(_) => self.build()?.call().await,
            EffectiveId::Subnet(subnet_id) => {
                let prepared = self.prepare()?;
                let response = subnet_call(
                    prepared.canister,
                    prepared.method,
                    prepared.arg_bytes,
                    subnet_id,
                )
                .await?;
                match response {
                    CallResponse::Response(bytes) => {
                        let (out,): (CreateCanisterOut,) = decode_args(&bytes)
                            .map_err(|e| AgentError::CandidError(Box::new(e)))?;
                        Ok(CallResponse::Response((out.canister_id,)))
                    }
                    CallResponse::Poll(request_id) => Ok(CallResponse::Poll(request_id)),
                }
            }
        }
    }

    /// Make a call. This is equivalent to the [`AsyncCall::call_and_wait`].
    pub async fn call_and_wait(self) -> Result<(Principal,), AgentError> {
        match self.effective_id {
            EffectiveId::Canister(_) => self.build()?.call_and_wait().await,
            EffectiveId::Subnet(subnet_id) => {
                let prepared = self.prepare()?;
                subnet_call_and_wait(
                    prepared.canister,
                    prepared.method,
                    prepared.arg_bytes,
                    subnet_id,
                )
                .await
            }
        }
    }

    fn prepare(self) -> Result<PreparedCreate<'agent, 'canister>, AgentError> {
        let settings = if let Some(settings) = self.settings {
            reject_mixed_settings(
                self.controllers.is_some()
                    || self.compute_allocation.is_some()
                    || self.memory_allocation.is_some()
                    || self.freezing_threshold.is_some()
                    || self.reserved_cycles_limit.is_some()
                    || self.wasm_memory_limit.is_some()
                    || self.wasm_memory_threshold.is_some()
                    || self.log_visibility.is_some()
                    || self.log_memory_limit.is_some()
                    || self.environment_variables.is_some()
                    || self.snapshot_visibility.is_some(),
            )?;
            settings
        } else {
            let controllers = match self.controllers {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(x),
                None => None,
            };
            let compute_allocation = match self.compute_allocation {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u8::from(x))),
                None => None,
            };
            let memory_allocation = match self.memory_allocation {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u64::from(x))),
                None => None,
            };
            let freezing_threshold = match self.freezing_threshold {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u64::from(x))),
                None => None,
            };
            let reserved_cycles_limit = match self.reserved_cycles_limit {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u128::from(x))),
                None => None,
            };
            let wasm_memory_limit = match self.wasm_memory_limit {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u64::from(x))),
                None => None,
            };
            let wasm_memory_threshold = match self.wasm_memory_threshold {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u64::from(x))),
                None => None,
            };
            let log_visibility = match self.log_visibility {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(x),
                None => None,
            };
            let log_memory_limit = match self.log_memory_limit {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u64::from(x))),
                None => None,
            };
            let environment_variables = match self.environment_variables {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(x),
                None => None,
            };
            let snapshot_visibility = match self.snapshot_visibility {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(x),
                None => None,
            };
            CanisterSettings {
                controllers,
                compute_allocation,
                memory_allocation,
                freezing_threshold,
                reserved_cycles_limit,
                wasm_memory_limit,
                wasm_memory_threshold,
                log_visibility,
                log_memory_limit,
                environment_variables,
                snapshot_visibility,
            }
        };

        let (method, arg_bytes) = if self.is_provisional_create {
            #[derive(CandidType)]
            struct In {
                amount: Option<Nat>,
                settings: CanisterSettings,
                specified_id: Option<Principal>,
            }
            let in_arg = In {
                amount: self.amount.map(Nat::from),
                settings,
                specified_id: self.specified_id,
            };
            (
                MgmtMethod::ProvisionalCreateCanisterWithCycles.as_ref(),
                Encode!(&in_arg).map_err(|e| AgentError::CandidError(Box::new(e)))?,
            )
        } else {
            (
                MgmtMethod::CreateCanister.as_ref(),
                Encode!(&settings).map_err(|e| AgentError::CandidError(Box::new(e)))?,
            )
        };

        Ok(PreparedCreate {
            canister: self.canister,
            effective_id: self.effective_id,
            method,
            arg_bytes,
        })
    }
}

#[derive(Deserialize, CandidType)]
struct CreateCanisterOut {
    canister_id: Principal,
}

struct PreparedCreate<'agent, 'canister> {
    canister: &'canister Canister<'agent>,
    effective_id: EffectiveId,
    method: &'static str,
    arg_bytes: Vec<u8>,
}

/// Submit a `create_canister` (or `provisional_create_canister_with_cycles`) call to the
/// management canister via the subnet-scoped endpoint and decode the resulting canister id.
async fn subnet_call_and_wait(
    canister: &Canister<'_>,
    method: &str,
    arg_bytes: Vec<u8>,
    subnet_id: Principal,
) -> Result<(Principal,), AgentError> {
    let agent = canister.agent;
    let signed = agent
        .update(&Principal::management_canister(), method)
        .with_arg(arg_bytes)
        .sign()?;
    let effective_id = EffectiveId::Subnet(subnet_id);
    let response = agent
        .update_signed(effective_id, signed.signed_update)
        .await?;
    let bytes = match response {
        CallResponse::Response(bytes) => bytes,
        CallResponse::Poll(request_id) => {
            let signed_status = agent.sign_request_status(effective_id, request_id)?;
            agent
                .wait_signed(
                    &request_id,
                    effective_id,
                    signed_status.signed_request_status,
                )
                .await?
                .0
        }
    };
    let (out,): (CreateCanisterOut,) =
        decode_args(&bytes).map_err(|e| AgentError::CandidError(Box::new(e)))?;
    Ok((out.canister_id,))
}

/// Like [`subnet_call_and_wait`] but returns a [`CallResponse`] without polling, so that the
/// caller can decide how to wait for the request to complete.
async fn subnet_call(
    canister: &Canister<'_>,
    method: &str,
    arg_bytes: Vec<u8>,
    subnet_id: Principal,
) -> Result<CallResponse<Vec<u8>>, AgentError> {
    let agent = canister.agent;
    let signed = agent
        .update(&Principal::management_canister(), method)
        .with_arg(arg_bytes)
        .sign()?;
    agent
        .update_signed(EffectiveId::Subnet(subnet_id), signed.signed_update)
        .await
}

#[cfg_attr(target_family = "wasm", async_trait(?Send))]
#[cfg_attr(not(target_family = "wasm"), async_trait)]
impl<'agent, 'canister: 'agent> AsyncCall for CreateCanisterBuilder<'agent, 'canister> {
    type Value = (Principal,);

    async fn call(self) -> Result<CallResponse<(Principal,)>, AgentError> {
        self.call().await
    }

    async fn call_and_wait(self) -> Result<(Principal,), AgentError> {
        self.call_and_wait().await
    }
}

impl<'agent, 'canister: 'agent> IntoFuture for CreateCanisterBuilder<'agent, 'canister> {
    type IntoFuture = CallFuture<'agent, (Principal,)>;
    type Output = Result<(Principal,), AgentError>;

    fn into_future(self) -> Self::IntoFuture {
        Box::pin(self.call_and_wait())
    }
}

#[doc(hidden)]
#[deprecated(since = "0.42.0", note = "Please use UpgradeFlags instead")]
pub type CanisterUpgradeOptions = UpgradeFlags;

#[doc(hidden)]
#[deprecated(since = "0.42.0", note = "Please use CanisterInstallMode instead")]
pub type InstallMode = CanisterInstallMode;

#[doc(hidden)]
#[deprecated(since = "0.42.0", note = "Please use InstallCodeArgs instead")]
pub type CanisterInstall = InstallCodeArgs;

/// A builder for an `install_code` call.
#[derive(Debug)]
pub struct InstallCodeBuilder<'agent, 'canister: 'agent> {
    canister: &'canister Canister<'agent>,
    canister_id: Principal,
    wasm: &'canister [u8],
    arg: Argument,
    mode: Option<CanisterInstallMode>,
}

impl<'agent, 'canister: 'agent> InstallCodeBuilder<'agent, 'canister> {
    /// Create an `InstallCode` builder, which is also an `AsyncCall` implementation.
    pub fn builder(
        canister: &'canister Canister<'agent>,
        canister_id: &Principal,
        wasm: &'canister [u8],
    ) -> Self {
        Self {
            canister,
            canister_id: *canister_id,
            wasm,
            arg: Default::default(),
            mode: None,
        }
    }

    /// Set the argument to the installation, which will be passed to the init
    /// method of the canister. Can be called at most once.
    pub fn with_arg<Argument: CandidType>(
        mut self,
        arg: Argument,
    ) -> InstallCodeBuilder<'agent, 'canister> {
        self.arg.set_idl_arg(arg);
        self
    }
    /// Set the argument with multiple arguments as tuple to the installation,
    /// which will be passed to the init method of the canister. Can be called at most once.
    pub fn with_args(mut self, tuple: impl ArgumentEncoder) -> Self {
        assert!(self.arg.0.is_none(), "argument is being set more than once");
        self.arg = Argument::from_candid(tuple);
        self
    }
    /// Set the argument passed in to the canister with raw bytes. Can be called at most once.
    pub fn with_raw_arg(mut self, arg: Vec<u8>) -> InstallCodeBuilder<'agent, 'canister> {
        self.arg.set_raw_arg(arg);
        self
    }

    /// Pass in the [`CanisterInstallMode`].
    pub fn with_mode(self, mode: CanisterInstallMode) -> Self {
        Self {
            mode: Some(mode),
            ..self
        }
    }

    /// Create an [`AsyncCall`] implementation that, when called, will install the
    /// canister.
    pub fn build(self) -> Result<impl 'agent + AsyncCall<Value = ()>, AgentError> {
        Ok(self
            .canister
            .update(MgmtMethod::InstallCode.as_ref())
            .with_arg(InstallCodeArgs {
                mode: self.mode.unwrap_or(CanisterInstallMode::Install),
                canister_id: self.canister_id,
                wasm_module: self.wasm.to_owned(),
                arg: self.arg.serialize()?,
                sender_canister_version: None,
            })
            .with_effective_canister_id(self.canister_id)
            .build())
    }

    /// Make a call. This is equivalent to the [`AsyncCall::call`].
    pub async fn call(self) -> Result<CallResponse<()>, AgentError> {
        self.build()?.call().await
    }

    /// Make a call. This is equivalent to the [`AsyncCall::call_and_wait`].
    pub async fn call_and_wait(self) -> Result<(), AgentError> {
        self.build()?.call_and_wait().await
    }
}

#[cfg_attr(target_family = "wasm", async_trait(?Send))]
#[cfg_attr(not(target_family = "wasm"), async_trait)]
impl<'agent, 'canister: 'agent> AsyncCall for InstallCodeBuilder<'agent, 'canister> {
    type Value = ();

    async fn call(self) -> Result<CallResponse<()>, AgentError> {
        self.build()?.call().await
    }

    async fn call_and_wait(self) -> Result<(), AgentError> {
        self.build()?.call_and_wait().await
    }
}

impl<'agent, 'canister: 'agent> IntoFuture for InstallCodeBuilder<'agent, 'canister> {
    type IntoFuture = CallFuture<'agent, ()>;
    type Output = Result<(), AgentError>;

    fn into_future(self) -> Self::IntoFuture {
        AsyncCall::call_and_wait(self)
    }
}

/// A builder for an `install_chunked_code` call.
#[derive(Debug)]
pub struct InstallChunkedCodeBuilder<'agent, 'canister> {
    canister: &'canister Canister<'agent>,
    target_canister: Principal,
    store_canister: Option<Principal>,
    chunk_hashes_list: Vec<ChunkHash>,
    wasm_module_hash: Vec<u8>,
    arg: Argument,
    mode: CanisterInstallMode,
}

impl<'agent: 'canister, 'canister> InstallChunkedCodeBuilder<'agent, 'canister> {
    /// Create an `InstallChunkedCodeBuilder`.
    pub fn builder(
        canister: &'canister Canister<'agent>,
        target_canister: Principal,
        wasm_module_hash: &[u8],
    ) -> Self {
        Self {
            canister,
            target_canister,
            wasm_module_hash: wasm_module_hash.to_vec(),
            store_canister: None,
            chunk_hashes_list: vec![],
            arg: Argument::new(),
            mode: CanisterInstallMode::Install,
        }
    }

    /// Set the chunks to install. These must previously have been set with [`ManagementCanister::upload_chunk`].
    pub fn with_chunk_hashes(mut self, chunk_hashes: Vec<ChunkHash>) -> Self {
        self.chunk_hashes_list = chunk_hashes;
        self
    }

    /// Set the canister to pull uploaded chunks from. By default this is the same as the target canister.
    pub fn with_store_canister(mut self, store_canister: Principal) -> Self {
        self.store_canister = Some(store_canister);
        self
    }

    /// Set the argument to the installation, which will be passed to the init
    /// method of the canister. Can be called at most once.
    pub fn with_arg(mut self, argument: impl CandidType) -> Self {
        self.arg.set_idl_arg(argument);
        self
    }

    /// Set the argument with multiple arguments as tuple to the installation,
    /// which will be passed to the init method of the canister. Can be called at most once.
    pub fn with_args(mut self, argument: impl ArgumentEncoder) -> Self {
        assert!(self.arg.0.is_none(), "argument is being set more than once");
        self.arg = Argument::from_candid(argument);
        self
    }

    /// Set the argument passed in to the canister with raw bytes. Can be called at most once.
    pub fn with_raw_arg(mut self, argument: Vec<u8>) -> Self {
        self.arg.set_raw_arg(argument);
        self
    }

    /// Set the [`CanisterInstallMode`].
    pub fn with_install_mode(mut self, mode: CanisterInstallMode) -> Self {
        self.mode = mode;
        self
    }

    /// Create an [`AsyncCall`] implementation that, when called, will install the canister.
    pub fn build(self) -> Result<impl 'agent + AsyncCall<Value = ()>, AgentError> {
        #[derive(CandidType)]
        struct In {
            mode: CanisterInstallMode,
            target_canister: Principal,
            store_canister: Option<Principal>,
            chunk_hashes_list: Vec<ChunkHash>,
            wasm_module_hash: Vec<u8>,
            arg: Vec<u8>,
            sender_canister_version: Option<u64>,
        }
        let Self {
            mode,
            target_canister,
            store_canister,
            chunk_hashes_list,
            wasm_module_hash,
            arg,
            ..
        } = self;
        Ok(self
            .canister
            .update(MgmtMethod::InstallChunkedCode.as_ref())
            .with_arg(In {
                mode,
                target_canister,
                store_canister,
                chunk_hashes_list,
                wasm_module_hash,
                arg: arg.serialize()?,
                sender_canister_version: None,
            })
            .with_effective_canister_id(target_canister)
            .build())
    }

    /// Make the call. This is equivalent to [`AsyncCall::call`].
    pub async fn call(self) -> Result<CallResponse<()>, AgentError> {
        self.build()?.call().await
    }

    /// Make the call. This is equivalent to [`AsyncCall::call_and_wait`].
    pub async fn call_and_wait(self) -> Result<(), AgentError> {
        self.build()?.call_and_wait().await
    }
}

#[cfg_attr(target_family = "wasm", async_trait(?Send))]
#[cfg_attr(not(target_family = "wasm"), async_trait)]
impl<'agent, 'canister: 'agent> AsyncCall for InstallChunkedCodeBuilder<'agent, 'canister> {
    type Value = ();

    async fn call(self) -> Result<CallResponse<()>, AgentError> {
        self.call().await
    }

    async fn call_and_wait(self) -> Result<(), AgentError> {
        self.call_and_wait().await
    }
}

impl<'agent, 'canister: 'agent> IntoFuture for InstallChunkedCodeBuilder<'agent, 'canister> {
    type IntoFuture = CallFuture<'agent, ()>;
    type Output = Result<(), AgentError>;

    fn into_future(self) -> Self::IntoFuture {
        AsyncCall::call_and_wait(self)
    }
}

/// A builder for a [`ManagementCanister::install`] call. This automatically selects one-shot installation or chunked installation depending on module size.
///
/// # Warnings
///
/// This will clear chunked code storage if chunked installation is used. Do not use with canisters that you are manually uploading chunked code to.
#[derive(Debug)]
pub struct InstallBuilder<'agent, 'canister, 'builder> {
    canister: &'canister ManagementCanister<'agent>,
    canister_id: Principal,
    // more precise lifetimes are used here at risk of annoying the user
    // because `wasm` may be memory-mapped which is tricky to lifetime
    wasm: &'builder [u8],
    arg: Argument,
    mode: CanisterInstallMode,
}

impl<'agent: 'canister, 'canister: 'builder, 'builder> InstallBuilder<'agent, 'canister, 'builder> {
    // Messages are a maximum of 2MiB. Thus basic installation should cap the wasm and arg size at 1.85MiB, since
    // the current API is definitely not going to produce 150KiB of framing data for it.
    const CHUNK_CUTOFF: usize = (1.85 * 1024. * 1024.) as usize;

    /// Create a canister installation builder.
    pub fn builder(
        canister: &'canister ManagementCanister<'agent>,
        canister_id: &Principal,
        wasm: &'builder [u8],
    ) -> Self {
        Self {
            canister,
            canister_id: *canister_id,
            wasm,
            arg: Default::default(),
            mode: CanisterInstallMode::Install,
        }
    }

    /// Set the argument to the installation, which will be passed to the init
    /// method of the canister. Can be called at most once.
    pub fn with_arg<Argument: CandidType>(mut self, arg: Argument) -> Self {
        self.arg.set_idl_arg(arg);
        self
    }
    /// Set the argument with multiple arguments as tuple to the installation,
    /// which will be passed to the init method of the canister. Can be called at most once.
    pub fn with_args(mut self, tuple: impl ArgumentEncoder) -> Self {
        assert!(self.arg.0.is_none(), "argument is being set more than once");
        self.arg = Argument::from_candid(tuple);
        self
    }
    /// Set the argument passed in to the canister with raw bytes. Can be called at most once.
    pub fn with_raw_arg(mut self, arg: Vec<u8>) -> Self {
        self.arg.set_raw_arg(arg);
        self
    }

    /// Pass in the [`CanisterInstallMode`].
    pub fn with_mode(self, mode: CanisterInstallMode) -> Self {
        Self { mode, ..self }
    }

    /// Invoke the installation process. This may result in many calls which may take several seconds;
    /// use [`call_and_wait_with_progress`](Self::call_and_wait_with_progress) if you want progress reporting.
    pub async fn call_and_wait(self) -> Result<(), AgentError> {
        self.call_and_wait_with_progress()
            .await
            .try_for_each(|_| ready(Ok(())))
            .await
    }

    /// Invoke the installation process. The returned stream must be iterated to completion; it is used to track progress,
    /// as installation may take arbitrarily long, and is intended to be passed to functions like `indicatif::ProgressBar::wrap_stream`.
    /// There are exactly [`size_hint().0`](Stream::size_hint) steps.
    pub async fn call_and_wait_with_progress(
        self,
    ) -> impl Stream<Item = Result<(), AgentError>> + 'builder {
        let stream_res = /* try { */ async move {
            let arg = self.arg.serialize()?;
            let stream: BoxStream<'_, _> =
                if self.wasm.len() + arg.len() < Self::CHUNK_CUTOFF {
                    Box::pin(
                        async move {
                            self.canister
                                .install_code(&self.canister_id, self.wasm)
                                .with_raw_arg(arg)
                                .with_mode(self.mode)
                                .call_and_wait()
                                .await
                        }
                        .into_stream(),
                    )
                } else {
                    let (existing_chunks,) = self.canister.stored_chunks(&self.canister_id).call_and_wait().await?;
                    let existing_chunks = existing_chunks.into_iter().map(|c| c.hash).collect::<BTreeSet<_>>();
                    let all_chunks = self.wasm.chunks(1024 * 1024).map(|x| (Sha256::digest(x).to_vec(), x)).collect::<Vec<_>>();
                    let mut to_upload_chunks = vec![];
                    for (hash, chunk) in &all_chunks {
                        if !existing_chunks.contains(hash) {
                            to_upload_chunks.push(*chunk);
                        }
                    }

                    let upload_chunks_stream = FuturesUnordered::new();
                    for chunk in to_upload_chunks {
                        upload_chunks_stream.push(async move {
                            let (_res,) = self
                                .canister
                                .upload_chunk(&self.canister_id, &ic_management_canister_types::UploadChunkArgs {
                                    canister_id: self.canister_id,
                                    chunk: chunk.to_vec(),
                                })
                                .call_and_wait()
                                .await?;
                            Ok(())
                        });
                    }
                    let install_chunked_code_stream = async move {
                        let results = all_chunks.iter().map(|(hash,_)| ChunkHash{ hash: hash.clone() }).collect();
                        self.canister
                            .install_chunked_code(
                                &self.canister_id,
                                &Sha256::digest(self.wasm),
                            )
                            .with_chunk_hashes(results)
                            .with_raw_arg(arg)
                            .with_install_mode(self.mode)
                            .call_and_wait()
                            .await
                    }
                    .into_stream();
                    let clear_store_stream = async move {
                        self.canister
                            .clear_chunk_store(&self.canister_id)
                            .call_and_wait()
                            .await
                    }
                    .into_stream();

                    Box::pin(
                        upload_chunks_stream
                            .chain(install_chunked_code_stream)
                            .chain(clear_store_stream                        ),
                    )
                };
            Ok(stream)
        }.await;
        match stream_res {
            Ok(stream) => stream,
            Err(err) => Box::pin(stream::once(async { Err(err) })),
        }
    }
}

impl<'agent: 'canister, 'canister: 'builder, 'builder> IntoFuture
    for InstallBuilder<'agent, 'canister, 'builder>
{
    type IntoFuture = CallFuture<'builder, ()>;
    type Output = Result<(), AgentError>;

    fn into_future(self) -> Self::IntoFuture {
        Box::pin(self.call_and_wait())
    }
}

/// A builder for an `update_settings` call.
#[derive(Debug)]
pub struct UpdateSettingsBuilder<'agent, 'canister: 'agent> {
    canister: &'canister Canister<'agent>,
    canister_id: Principal,
    controllers: Option<Result<Vec<Principal>, AgentError>>,
    compute_allocation: Option<Result<ComputeAllocation, AgentError>>,
    memory_allocation: Option<Result<MemoryAllocation, AgentError>>,
    freezing_threshold: Option<Result<FreezingThreshold, AgentError>>,
    reserved_cycles_limit: Option<Result<ReservedCyclesLimit, AgentError>>,
    wasm_memory_limit: Option<Result<WasmMemoryLimit, AgentError>>,
    wasm_memory_threshold: Option<Result<WasmMemoryLimit, AgentError>>,
    log_visibility: Option<Result<LogVisibility, AgentError>>,
    log_memory_limit: Option<Result<LogMemoryLimit, AgentError>>,
    environment_variables: Option<Result<Vec<EnvironmentVariable>, AgentError>>,
    snapshot_visibility: Option<Result<SnapshotVisibility, AgentError>>,
    settings: Option<CanisterSettings>,
}

impl<'agent, 'canister: 'agent> UpdateSettingsBuilder<'agent, 'canister> {
    /// Create an `UpdateCanister` builder, which is also an `AsyncCall` implementation.
    pub fn builder(canister: &'canister Canister<'agent>, canister_id: &Principal) -> Self {
        Self {
            canister,
            canister_id: *canister_id,
            controllers: None,
            compute_allocation: None,
            memory_allocation: None,
            freezing_threshold: None,
            reserved_cycles_limit: None,
            wasm_memory_limit: None,
            wasm_memory_threshold: None,
            log_visibility: None,
            log_memory_limit: None,
            environment_variables: None,
            snapshot_visibility: None,
            settings: None,
        }
    }

    /// Pass in a controller for the canister. Can be called multiple times to add multiple controllers.
    pub fn with_controller<C, E>(self, controller: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<Principal, Error = E>,
    {
        let controller_result = controller
            .try_into()
            .map_err(|e| AgentError::MessageError(format!("{e}")));
        let controllers = match (controller_result, self.controllers) {
            (_, Some(Err(sticky))) => Some(Err(sticky)),
            (Err(e), _) => Some(Err(e)),
            (Ok(controller), Some(Ok(mut controllers))) => {
                controllers.push(controller);
                Some(Ok(controllers))
            }
            (Ok(controller), None) => Some(Ok(vec![controller])),
        };
        Self {
            controllers,
            ..self
        }
    }

    /// Pass in a compute allocation value for the canister.
    pub fn with_compute_allocation<C, E>(self, compute_allocation: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<ComputeAllocation, Error = E>,
    {
        Self {
            compute_allocation: Some(
                compute_allocation
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a memory allocation value for the canister.
    pub fn with_memory_allocation<C, E>(self, memory_allocation: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<MemoryAllocation, Error = E>,
    {
        Self {
            memory_allocation: Some(
                memory_allocation
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a freezing threshold value for the canister.
    pub fn with_freezing_threshold<C, E>(self, freezing_threshold: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<FreezingThreshold, Error = E>,
    {
        Self {
            freezing_threshold: Some(
                freezing_threshold
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a reserved cycles limit value for the canister.
    pub fn with_reserved_cycles_limit<C, E>(self, limit: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<ReservedCyclesLimit, Error = E>,
    {
        Self {
            reserved_cycles_limit: Some(
                limit
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a Wasm memory limit value for the canister.
    pub fn with_wasm_memory_limit<C, E>(self, wasm_memory_limit: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<WasmMemoryLimit, Error = E>,
    {
        Self {
            wasm_memory_limit: Some(
                wasm_memory_limit
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a Wasm memory threshold value for the canister.
    pub fn with_wasm_memory_threshold<C, E>(self, wasm_memory_threshold: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<WasmMemoryLimit, Error = E>,
    {
        Self {
            wasm_memory_threshold: Some(
                wasm_memory_threshold
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a log memory limit value for the canister.
    pub fn with_log_memory_limit<C, E>(self, log_memory_limit: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<LogMemoryLimit, Error = E>,
    {
        Self {
            log_memory_limit: Some(
                log_memory_limit
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a log visibility setting for the canister.
    pub fn with_log_visibility<C, E>(self, log_visibility: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<LogVisibility, Error = E>,
    {
        Self {
            log_visibility: Some(
                log_visibility
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in environment variables for the canister.
    pub fn with_environment_variables<C, E>(self, environment_variables: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<Vec<EnvironmentVariable>, Error = E>,
    {
        Self {
            environment_variables: Some(
                environment_variables
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a snapshot visibility setting for the canister.
    pub fn with_snapshot_visibility<C, E>(self, snapshot_visibility: C) -> Self
    where
        E: std::fmt::Display,
        C: TryInto<SnapshotVisibility, Error = E>,
    {
        Self {
            snapshot_visibility: Some(
                snapshot_visibility
                    .try_into()
                    .map_err(|e| AgentError::MessageError(format!("{e}"))),
            ),
            ..self
        }
    }

    /// Pass in a complete [`CanisterSettings`] to apply.
    ///
    /// This is a convenience for callers that already hold a `CanisterSettings`
    /// (e.g. decoded from a config or forwarded from another call) and do not
    /// want to decompose it into individual setters.
    ///
    /// It is currently **mutually exclusive** with the individual settings
    /// setters (`with_controller`, `with_compute_allocation`, …): building the
    /// call returns an error if this method is combined with any of them.
    pub fn with_canister_settings(self, settings: CanisterSettings) -> Self {
        Self {
            settings: Some(settings),
            ..self
        }
    }

    /// Create an [`AsyncCall`] implementation that, when called, will update a
    /// canisters settings.
    pub fn build(self) -> Result<impl 'agent + AsyncCall<Value = ()>, AgentError> {
        #[derive(CandidType)]
        struct In {
            canister_id: Principal,
            settings: CanisterSettings,
        }

        let settings = if let Some(settings) = self.settings {
            reject_mixed_settings(
                self.controllers.is_some()
                    || self.compute_allocation.is_some()
                    || self.memory_allocation.is_some()
                    || self.freezing_threshold.is_some()
                    || self.reserved_cycles_limit.is_some()
                    || self.wasm_memory_limit.is_some()
                    || self.wasm_memory_threshold.is_some()
                    || self.log_visibility.is_some()
                    || self.log_memory_limit.is_some()
                    || self.environment_variables.is_some()
                    || self.snapshot_visibility.is_some(),
            )?;
            settings
        } else {
            let controllers = match self.controllers {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(x),
                None => None,
            };
            let compute_allocation = match self.compute_allocation {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u8::from(x))),
                None => None,
            };
            let memory_allocation = match self.memory_allocation {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u64::from(x))),
                None => None,
            };
            let freezing_threshold = match self.freezing_threshold {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u64::from(x))),
                None => None,
            };
            let reserved_cycles_limit = match self.reserved_cycles_limit {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u128::from(x))),
                None => None,
            };
            let wasm_memory_limit = match self.wasm_memory_limit {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u64::from(x))),
                None => None,
            };
            let wasm_memory_threshold = match self.wasm_memory_threshold {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u64::from(x))),
                None => None,
            };
            let log_visibility = match self.log_visibility {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(x),
                None => None,
            };
            let log_memory_limit = match self.log_memory_limit {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(Nat::from(u64::from(x))),
                None => None,
            };
            let environment_variables = match self.environment_variables {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(x),
                None => None,
            };
            let snapshot_visibility = match self.snapshot_visibility {
                Some(Err(x)) => return Err(AgentError::MessageError(format!("{x}"))),
                Some(Ok(x)) => Some(x),
                None => None,
            };
            CanisterSettings {
                controllers,
                compute_allocation,
                memory_allocation,
                freezing_threshold,
                reserved_cycles_limit,
                wasm_memory_limit,
                wasm_memory_threshold,
                log_visibility,
                log_memory_limit,
                environment_variables,
                snapshot_visibility,
            }
        };

        Ok(self
            .canister
            .update(MgmtMethod::UpdateSettings.as_ref())
            .with_arg(In {
                canister_id: self.canister_id,
                settings,
            })
            .with_effective_canister_id(self.canister_id)
            .build())
    }

    /// Make a call. This is equivalent to the [`AsyncCall::call`].
    pub async fn call(self) -> Result<CallResponse<()>, AgentError> {
        self.build()?.call().await
    }

    /// Make a call. This is equivalent to the [`AsyncCall::call_and_wait`].
    pub async fn call_and_wait(self) -> Result<(), AgentError> {
        self.build()?.call_and_wait().await
    }
}

#[cfg_attr(target_family = "wasm", async_trait(?Send))]
#[cfg_attr(not(target_family = "wasm"), async_trait)]
impl<'agent, 'canister: 'agent> AsyncCall for UpdateSettingsBuilder<'agent, 'canister> {
    type Value = ();
    async fn call(self) -> Result<CallResponse<()>, AgentError> {
        self.build()?.call().await
    }

    async fn call_and_wait(self) -> Result<(), AgentError> {
        self.build()?.call_and_wait().await
    }
}

impl<'agent, 'canister: 'agent> IntoFuture for UpdateSettingsBuilder<'agent, 'canister> {
    type IntoFuture = CallFuture<'agent, ()>;
    type Output = Result<(), AgentError>;
    fn into_future(self) -> Self::IntoFuture {
        AsyncCall::call_and_wait(self)
    }
}

#[cfg(not(target_family = "wasm"))]
type BoxStream<'a, T> = Pin<Box<dyn Stream<Item = T> + Send + 'a>>;
#[cfg(target_family = "wasm")]
type BoxStream<'a, T> = Pin<Box<dyn Stream<Item = T> + 'a>>;