diff --git a/diced/src/utils.rs b/diced/src/utils.rs
index 05702ad..3d35ae5 100644
--- a/diced/src/utils.rs
+++ b/diced/src/utils.rs
@@ -19,63 +19,32 @@
     Mode::Mode as BinderMode,
 };
 use anyhow::{Context, Result};
-use dice::{ContextImpl, DiceMode, Hash, Hidden};
+use dice::{ContextImpl, DiceMode};
 use diced_open_dice_cbor as dice;
 use keystore2_crypto::ZVec;
 use std::convert::TryInto;
 
-/// This new type wraps a reference to BinderInputValues and implements the open dice
-/// InputValues trait.
-#[derive(Debug)]
-pub struct InputValues<'a>(&'a BinderInputValues);
-
-impl<'a> From<&'a BinderInputValues> for InputValues<'a> {
-    fn from(input_values: &'a BinderInputValues) -> InputValues<'a> {
-        Self(input_values)
+/// Converts the `InputValues` from the binder to the `InputValues` type in `diced_open_dice` crate.
+pub fn to_dice_input_values(input: &BinderInputValues) -> dice::InputValues {
+    if input.authorityDescriptor.is_some() {
+        unimplemented!("Authority descriptor is not yet implemented in the current library.");
     }
+    dice::InputValues::new(
+        input.codeHash,
+        dice::Config::Descriptor(input.config.desc.as_slice()),
+        input.authorityHash,
+        to_dice_mode(input.mode),
+        input.hidden,
+    )
 }
 
-impl From<&InputValues<'_>> for BinderInputValues {
-    fn from(input_values: &InputValues) -> BinderInputValues {
-        input_values.0.clone()
-    }
-}
-impl From<InputValues<'_>> for BinderInputValues {
-    fn from(input_values: InputValues) -> BinderInputValues {
-        input_values.0.clone()
-    }
-}
-
-impl dice::InputValues for InputValues<'_> {
-    fn code_hash(&self) -> &Hash {
-        &self.0.codeHash
-    }
-
-    fn config(&self) -> dice::Config {
-        dice::Config::Descriptor(self.0.config.desc.as_slice())
-    }
-
-    fn authority_hash(&self) -> &Hash {
-        &self.0.authorityHash
-    }
-
-    fn authority_descriptor(&self) -> Option<&[u8]> {
-        self.0.authorityDescriptor.as_deref()
-    }
-
-    fn mode(&self) -> DiceMode {
-        match self.0.mode {
-            BinderMode::NOT_INITIALIZED => DiceMode::kDiceModeNotInitialized,
-            BinderMode::NORMAL => DiceMode::kDiceModeNormal,
-            BinderMode::DEBUG => DiceMode::kDiceModeDebug,
-            BinderMode::RECOVERY => DiceMode::kDiceModeMaintenance,
-            _ => DiceMode::kDiceModeNotInitialized,
-        }
-    }
-
-    fn hidden(&self) -> &Hidden {
-        // If `self` was created using try_from the length was checked and this cannot panic.
-        &self.0.hidden
+fn to_dice_mode(binder_mode: BinderMode) -> DiceMode {
+    match binder_mode {
+        BinderMode::NOT_INITIALIZED => DiceMode::kDiceModeNotInitialized,
+        BinderMode::NORMAL => DiceMode::kDiceModeNormal,
+        BinderMode::DEBUG => DiceMode::kDiceModeDebug,
+        BinderMode::RECOVERY => DiceMode::kDiceModeMaintenance,
+        _ => DiceMode::kDiceModeNotInitialized,
     }
 }
 
@@ -153,7 +122,7 @@
         (cdi_attest, cdi_seal, bcc)
     }
 
-    fn execute_step(self, input_values: InputValues) -> Result<Self> {
+    fn execute_step(self, input_values: &BinderInputValues) -> Result<Self> {
         let ResidentArtifacts { cdi_attest, cdi_seal, bcc } = self;
 
         let (cdi_attest, cdi_seal, bcc) = dice::OpenDiceCborContext::new()
@@ -165,7 +134,7 @@
                     format!("Trying to convert cdi_seal. (length: {})", cdi_seal.len())
                 })?,
                 &bcc,
-                &input_values,
+                &to_dice_input_values(input_values),
             )
             .context("In ResidentArtifacts::execute_step:")?;
         Ok(ResidentArtifacts { cdi_attest, cdi_seal, bcc })
@@ -173,14 +142,13 @@
 
     /// Iterate through the iterator of dice input values performing one
     /// BCC main flow step on each element.
-    pub fn execute_steps<'a, T, I>(self, input_values: I) -> Result<Self>
+    pub fn execute_steps<'a, I>(self, input_values: I) -> Result<Self>
     where
-        T: Into<InputValues<'a>>,
-        I: IntoIterator<Item = T>,
+        I: IntoIterator<Item = &'a BinderInputValues>,
     {
         input_values
             .into_iter()
-            .try_fold(self, |acc, input| acc.execute_step(input.into()))
+            .try_fold(self, |acc, input| acc.execute_step(input))
             .context("In ResidentArtifacts::execute_step:")
     }
 }