fix json deserialization into stableswap pool type

packages/osmosis-std/src/serde/mod.rs

@@ -20,3 +20,30 @@ pub mod as_str {
         serializer.serialize_str(&value.to_string())
     }
 }
+
+pub mod as_str_vec {
+    use serde::{de, Deserialize, Deserializer, Serializer, Serialize};
+    use std::{fmt::Display, str::FromStr};
+
+    pub fn deserialize<'de, T, D>(deserializer: D) -> Result<Vec<T>, D::Error>
+    where
+        T: FromStr,
+        T::Err: Display,
+        D: Deserializer<'de>,
+    {
+        let vec_of_strings: Vec<String> = Vec::deserialize(deserializer)?;
+        vec_of_strings
+            .into_iter()
+            .map(|s| T::from_str(&s).map_err(de::Error::custom))
+            .collect()
+    }
+
+    pub fn serialize<S, T>(values: &Vec<T>, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+        T: Display,
+    {
+        let vec_of_strings: Vec<String> = values.iter().map(|value| value.to_string()).collect();
+        vec_of_strings.serialize(serializer)
+    }
+}

packages/osmosis-std/src/types/osmosis/gamm/poolmodels/stableswap/v1beta1.rs

@@ -69,6 +69,10 @@ pub struct Pool {
         ::prost::alloc::vec::Vec<super::super::super::super::super::cosmos::base::v1beta1::Coin>,
     /// for calculation amognst assets with different precisions
     #[prost(uint64, repeated, packed = "false", tag = "7")]
+    #[serde(
+        serialize_with = "crate::serde::as_str_vec::serialize",
+        deserialize_with = "crate::serde::as_str_vec::deserialize"
+    )]
     pub scaling_factors: ::prost::alloc::vec::Vec<u64>,
     /// scaling_factor_controller is the address can adjust pool scaling factors
     #[prost(string, tag = "8")]

packages/proto-build/src/transform.rs

@@ -161,7 +161,8 @@ fn transform_items(
                 let s = transformers::add_derive_eq_struct(&s);
                 let s = transformers::append_attrs_struct(src, &s, descriptor);
                 let s = transformers::serde_alias_id_with_uppercased(s);
-                transformers::allow_serde_int_as_str(s)
+                let s = transformers::allow_serde_int_as_str(s);
+                transformers::allow_serde_vec_int_as_vec_str(s)
             }),
 
             Item::Enum(e) => Item::Enum({

packages/proto-build/src/transformers.rs

@@ -191,6 +191,50 @@ pub fn allow_serde_int_as_str(s: ItemStruct) -> ItemStruct {
     syn::ItemStruct { fields, ..s }
 }
 
+pub fn allow_serde_vec_int_as_vec_str(s: ItemStruct) -> ItemStruct {
+    let fields_vec = s
+        .fields
+        .clone()
+        .into_iter()
+        .map(|mut field| {
+            let int_types = vec![
+                parse_quote!(vec![i8]),
+                parse_quote!(vec![i16]),
+                parse_quote!(vec![i32]),
+                parse_quote!(vec![i64]),
+                parse_quote!(vec![i128]),
+                parse_quote!(vec![isize]),
+                parse_quote!(vec![u8]),
+                parse_quote!(vec![u16]),
+                parse_quote!(vec![u32]),
+                parse_quote!(vec![u64]),
+                parse_quote!(vec![u128]),
+                parse_quote!(vec![usize]),
+            ];
+
+            if int_types.contains(&field.ty) {
+                let from_str: syn::Attribute = parse_quote! {
+                    #[serde(
+                        serialize_with = "crate::serde::as_str_vec::serialize",
+                        deserialize_with = "crate::serde::as_str_vec::deserialize"
+                    )]
+                };
+                field.attrs.append(&mut vec![from_str]);
+                field
+            } else {
+                field
+            }
+        })
+        .collect::<Vec<syn::Field>>();
+
+    let fields_named: syn::FieldsNamed = parse_quote! {
+        { #(#fields_vec,)* }
+    };
+    let fields = syn::Fields::Named(fields_named);
+
+    syn::ItemStruct { fields, ..s }
+}
+
 /// some of proto's fields in osmosis' modules are named `ID` but prost generates `id` field
 /// this function adds `#[serde(alias = "ID")]` to the `id` field
 /// so that serde can deserialize `ID` field to `id` field.