diff --git a/arrow-cast/src/cast/decimal.rs b/arrow-cast/src/cast/decimal.rs
index 6fd96626f23..39c243bd28b 100644
--- a/arrow-cast/src/cast/decimal.rs
+++ b/arrow-cast/src/cast/decimal.rs
@@ -26,7 +26,7 @@ pub(crate) trait DecimalCast: Sized {
 
     fn from_decimal<T: DecimalCast>(n: T) -> Option<Self>;
 
-    fn from_f64<T: DecimalCast>(n: f64) -> Option<Self>;
+    fn from_f64(n: f64) -> Option<Self>;
 }
 
 impl DecimalCast for i128 {
@@ -42,7 +42,7 @@ impl DecimalCast for i128 {
         n.to_i128()
     }
 
-    fn from_f64<T: DecimalCast>(n: f64) -> Option<Self> {
+    fn from_f64(n: f64) -> Option<Self> {
         n.to_i128()
     }
 }
@@ -60,7 +60,7 @@ impl DecimalCast for i256 {
         n.to_i256()
     }
 
-    fn from_f64<T: DecimalCast>(n: f64) -> Option<Self> {
+    fn from_f64(n: f64) -> Option<Self> {
         i256::from_f64(n)
     }
 }
@@ -474,7 +474,7 @@ where
     Ok(Arc::new(result))
 }
 
-pub(crate) fn cast_floating_point_to_decimal<T: ArrowPrimitiveType, D, M>(
+pub(crate) fn cast_floating_point_to_decimal<T: ArrowPrimitiveType, D>(
     array: &PrimitiveArray<T>,
     precision: u8,
     scale: i8,
@@ -482,15 +482,15 @@ pub(crate) fn cast_floating_point_to_decimal<T: ArrowPrimitiveType, D, M>(
 ) -> Result<ArrayRef, ArrowError>
 where
     <T as ArrowPrimitiveType>::Native: AsPrimitive<f64>,
-    D: DecimalType + ArrowPrimitiveType<Native = M>,
-    M: ArrowNativeTypeOp + DecimalCast,
+    D: DecimalType + ArrowPrimitiveType,
+    <D as ArrowPrimitiveType>::Native: DecimalCast,
 {
     let mul = 10_f64.powi(scale as i32);
 
     if cast_options.safe {
         array
             .unary_opt::<_, D>(|v| {
-                M::from_f64::<M>((mul * v.as_()).round())
+                D::Native::from_f64((mul * v.as_()).round())
                     .filter(|v| D::is_valid_decimal_precision(*v, precision))
             })
             .with_precision_and_scale(precision, scale)
@@ -498,7 +498,7 @@ where
     } else {
         array
             .try_unary::<_, D, _>(|v| {
-                M::from_f64::<M>((mul * v.as_()).round())
+                D::Native::from_f64((mul * v.as_()).round())
                     .ok_or_else(|| {
                         ArrowError::CastError(format!(
                             "Cannot cast to {}({}, {}). Overflowing on {:?}",
diff --git a/arrow-cast/src/cast/dictionary.rs b/arrow-cast/src/cast/dictionary.rs
index 0fd8997555f..dda4a93e5ea 100644
--- a/arrow-cast/src/cast/dictionary.rs
+++ b/arrow-cast/src/cast/dictionary.rs
@@ -214,14 +214,14 @@ pub(crate) fn cast_to_dictionary<K: ArrowDictionaryKeyType>(
         UInt16 => pack_numeric_to_dictionary::<K, UInt16Type>(array, dict_value_type, cast_options),
         UInt32 => pack_numeric_to_dictionary::<K, UInt32Type>(array, dict_value_type, cast_options),
         UInt64 => pack_numeric_to_dictionary::<K, UInt64Type>(array, dict_value_type, cast_options),
-        Decimal128(p, s) => pack_decimal_to_dictionary::<K, Decimal128Type, _>(
+        Decimal128(p, s) => pack_decimal_to_dictionary::<K, Decimal128Type>(
             array,
             dict_value_type,
             p,
             s,
             cast_options,
         ),
-        Decimal256(p, s) => pack_decimal_to_dictionary::<K, Decimal256Type, _>(
+        Decimal256(p, s) => pack_decimal_to_dictionary::<K, Decimal256Type>(
             array,
             dict_value_type,
             p,
@@ -329,7 +329,7 @@ where
     Ok(Arc::new(b.finish()))
 }
 
-pub(crate) fn pack_decimal_to_dictionary<K, D, M>(
+pub(crate) fn pack_decimal_to_dictionary<K, D>(
     array: &dyn Array,
     dict_value_type: &DataType,
     precision: u8,
@@ -338,15 +338,14 @@ pub(crate) fn pack_decimal_to_dictionary<K, D, M>(
 ) -> Result<ArrayRef, ArrowError>
 where
     K: ArrowDictionaryKeyType,
-    D: DecimalType + ArrowPrimitiveType<Native = M>,
-    M: ArrowNativeTypeOp + DecimalCast,
+    D: DecimalType + ArrowPrimitiveType,
 {
     let dict = pack_numeric_to_dictionary::<K, D>(array, dict_value_type, cast_options)?;
     let dict = dict
         .as_dictionary::<K>()
         .downcast_dict::<PrimitiveArray<D>>()
         .ok_or_else(|| {
-            ArrowError::ComputeError(format!("Internal Error: Cannot cast dict to {}", D::PREFIX))
+            ArrowError::ComputeError(format!("Internal Error: Cannot cast dict to {}Array", D::PREFIX))
         })?;
     let value = dict.values().clone();
     // Set correct precision/scale
diff --git a/arrow-cast/src/cast/mod.rs b/arrow-cast/src/cast/mod.rs
index 1fa4bd9ec40..ab296843900 100644
--- a/arrow-cast/src/cast/mod.rs
+++ b/arrow-cast/src/cast/mod.rs
@@ -2051,13 +2051,13 @@ where
             base,
             cast_options,
         ),
-        Float32 => cast_floating_point_to_decimal::<_, D, _>(
+        Float32 => cast_floating_point_to_decimal::<_, D>(
             array.as_primitive::<Float32Type>(),
             *precision,
             *scale,
             cast_options,
         ),
-        Float64 => cast_floating_point_to_decimal::<_, D, _>(
+        Float64 => cast_floating_point_to_decimal::<_, D>(
             array.as_primitive::<Float64Type>(),
             *precision,
             *scale,
diff --git a/arrow-schema/src/ffi.rs b/arrow-schema/src/ffi.rs
index f6fcc8f275b..d86fb66190b 100644
--- a/arrow-schema/src/ffi.rs
+++ b/arrow-schema/src/ffi.rs
@@ -520,10 +520,9 @@ impl TryFrom<&FFI_ArrowSchema> for DataType {
                                         "The decimal type requires an integer scale".to_string(),
                                     )
                                 })?;
-                                let parsed_bits = bits.parse::<u16>().unwrap_or(0);
-                                match parsed_bits {
-                                    128 => DataType::Decimal128(parsed_precision, parsed_scale),
-                                    256 => DataType::Decimal256(parsed_precision, parsed_scale),
+                                match *bits {
+                                    "128" => DataType::Decimal128(parsed_precision, parsed_scale),
+                                    "256" => DataType::Decimal256(parsed_precision, parsed_scale),
                                     _ => return Err(ArrowError::CDataInterface("Only 128- and 256- bit wide decimals are supported in the Rust implementation".to_string())),
                                 }
                             }