Update deps to use scale-type-resolver 0.2 (#1565)

* Updates for scale-type-resolver 0.2

* show that we can check the name too now

* Bump versions and fix WrapperKeepOpaque name check

core/src/utils/bits.rs

@@ -156,7 +156,7 @@ impl<Store, Order, R: TypeResolver> scale_decode::Visitor for DecodedBitsVisitor
     fn unchecked_decode_as_type<'scale, 'info>(
         self,
         input: &mut &'scale [u8],
-        type_id: &R::TypeId,
+        type_id: R::TypeId,
         types: &'info R,
     ) -> scale_decode::visitor::DecodeAsTypeResult<
         Self,
@@ -181,7 +181,7 @@ impl<Store, Order> scale_decode::IntoVisitor for DecodedBits<Store, Order> {
 impl<Store, Order> scale_encode::EncodeAsType for DecodedBits<Store, Order> {
     fn encode_as_type_to<R: TypeResolver>(
         &self,
-        type_id: &R::TypeId,
+        type_id: R::TypeId,
         types: &R,
         out: &mut Vec<u8>,
     ) -> Result<(), scale_encode::Error> {

core/src/utils/static_type.rs

@@ -22,7 +22,7 @@ pub struct Static<T>(pub T);
 impl<T: Encode> EncodeAsType for Static<T> {
     fn encode_as_type_to<R: TypeResolver>(
         &self,
-        _type_id: &R::TypeId,
+        _type_id: R::TypeId,
         _types: &R,
         out: &mut Vec<u8>,
     ) -> Result<(), scale_encode::Error> {
@@ -41,7 +41,7 @@ impl<T: Decode, R: TypeResolver> Visitor for StaticDecodeAsTypeVisitor<T, R> {
     fn unchecked_decode_as_type<'scale, 'info>(
         self,
         input: &mut &'scale [u8],
-        _type_id: &R::TypeId,
+        _type_id: R::TypeId,
         _types: &'info R,
     ) -> DecodeAsTypeResult<Self, Result<Self::Value<'scale, 'info>, Self::Error>> {
         use scale_decode::{visitor::DecodeError, Error};

core/src/utils/unchecked_extrinsic.rs

@@ -55,7 +55,7 @@ impl<Address, Call, Signature, Extra> scale_encode::EncodeAsType
 {
     fn encode_as_type_to<R: TypeResolver>(
         &self,
-        type_id: &R::TypeId,
+        type_id: R::TypeId,
         types: &R,
         out: &mut Vec<u8>,
     ) -> Result<(), scale_encode::Error> {
@@ -93,7 +93,7 @@ impl<Address, Call, Signature, Extra, R: TypeResolver> Visitor
     fn unchecked_decode_as_type<'scale, 'info>(
         self,
         input: &mut &'scale [u8],
-        type_id: &R::TypeId,
+        type_id: R::TypeId,
         types: &'info R,
     ) -> DecodeAsTypeResult<Self, Result<Self::Value<'scale, 'info>, Self::Error>> {
         DecodeAsTypeResult::Decoded(Self::Value::decode_as_type(input, type_id, types))

core/src/utils/wrapper_opaque.rs

@@ -72,26 +72,27 @@ impl<T> WrapperKeepOpaque<T> {
 impl<T> EncodeAsType for WrapperKeepOpaque<T> {
     fn encode_as_type_to<R: TypeResolver>(
         &self,
-        type_id: &R::TypeId,
+        type_id: R::TypeId,
         types: &R,
         out: &mut Vec<u8>,
     ) -> Result<(), scale_encode::Error> {
         use scale_encode::error::{Error, ErrorKind, Kind};
 
-        let visitor = visitor::new(out, |_, _| {
+        let ctx = (type_id.clone(), out);
+        let visitor = visitor::new(ctx, |(type_id, _out), _| {
             // Check that the target shape lines up: any other shape but composite is wrong.
             Err(Error::new(ErrorKind::WrongShape {
                 actual: Kind::Struct,
-                expected_id: format!("{:?}", type_id),
+                expected_id: format!("{type_id:?}"),
             }))
         })
-        .visit_composite(|out, _fields| {
+        .visit_composite(|(_type_id, out), _path, _fields| {
             self.data.encode_to(out);
             Ok(())
         });
 
         types
-            .resolve_type(type_id, visitor)
+            .resolve_type(type_id.clone(), visitor)
             .map_err(|_| Error::new(ErrorKind::TypeNotFound(format!("{:?}", type_id))))?
     }
 }
@@ -105,11 +106,19 @@ impl<T, R: TypeResolver> Visitor for WrapperKeepOpaqueVisitor<T, R> {
     fn visit_composite<'scale, 'info>(
         self,
         value: &mut scale_decode::visitor::types::Composite<'scale, 'info, R>,
-        _type_id: &R::TypeId,
+        _type_id: R::TypeId,
     ) -> Result<Self::Value<'scale, 'info>, Self::Error> {
         use scale_decode::error::{Error, ErrorKind};
+        use scale_decode::visitor::DecodeError;
 
-        // TODO: When `scale-type-resolver` [provides struct names](https://github.com/paritytech/scale-type-resolver/issues/4), check that this struct name is `WrapperKeepOpaque`
+        if value.name() != Some("WrapperKeepOpaque") {
+            return Err(Error::new(ErrorKind::VisitorDecodeError(
+                DecodeError::TypeResolvingError(format!(
+                    "Expected a type named 'WrapperKeepOpaque', got: {:?}",
+                    value.name()
+                )),
+            )));
+        }
 
         if value.remaining() != 2 {
             return Err(Error::new(ErrorKind::WrongLength {
@@ -193,7 +202,7 @@ mod test {
         let (type_id, types) = make_type::<T>();
 
         let scale_codec_encoded = t.encode();
-        let encode_as_type_encoded = t.encode_as_type(&type_id, &types).unwrap();
+        let encode_as_type_encoded = t.encode_as_type(type_id, &types).unwrap();
 
         assert_eq!(
             scale_codec_encoded, encode_as_type_encoded,
@@ -201,7 +210,7 @@ mod test {
         );
 
         let decode_as_type_bytes = &mut &*scale_codec_encoded;
-        let decoded_as_type = T::decode_as_type(decode_as_type_bytes, &type_id, &types)
+        let decoded_as_type = T::decode_as_type(decode_as_type_bytes, type_id, &types)
             .expect("decode-as-type decodes");
 
         let decode_scale_codec_bytes = &mut &*scale_codec_encoded;