scale-type-resolver integration (#1460)

* start migrating, broken

* first iteration of updating

* fmt and clippy

* add Composite<u32> decoding via scale value patch

* bump scale type gen versions

* fix decoding with new scale decode

* fix js-sys versions

* add nit comments

subxt/src/utils/bits.rs

@@ -9,7 +9,8 @@ use scale_bits::{
     scale::format::{Format, OrderFormat, StoreFormat},
     Bits,
 };
-use scale_decode::IntoVisitor;
+use scale_decode::{IntoVisitor, TypeResolver};
+
 use std::marker::PhantomData;
 
 /// Associates `bitvec::store::BitStore` trait with corresponding, type-erased `scale_bits::StoreFormat` enum.
@@ -144,45 +145,43 @@ impl<Store: BitStore, Order: BitOrder> codec::Encode for DecodedBits<Store, Orde
 }
 
 #[doc(hidden)]
-pub struct DecodedBitsVisitor<S, O>(std::marker::PhantomData<(S, O)>);
-impl<Store, Order> scale_decode::Visitor for DecodedBitsVisitor<Store, Order> {
+pub struct DecodedBitsVisitor<S, O, R: TypeResolver>(std::marker::PhantomData<(S, O, R)>);
+
+impl<Store, Order, R: TypeResolver> scale_decode::Visitor for DecodedBitsVisitor<Store, Order, R> {
     type Value<'scale, 'info> = DecodedBits<Store, Order>;
     type Error = scale_decode::Error;
+    type TypeResolver = R;
 
     fn unchecked_decode_as_type<'scale, 'info>(
         self,
         input: &mut &'scale [u8],
-        type_id: scale_decode::visitor::TypeId,
-        types: &'info scale_info::PortableRegistry,
+        type_id: &R::TypeId,
+        types: &'info R,
     ) -> scale_decode::visitor::DecodeAsTypeResult<
         Self,
         Result<Self::Value<'scale, 'info>, Self::Error>,
     > {
-        let res = scale_decode::visitor::decode_with_visitor(
-            input,
-            type_id.0,
-            types,
-            Bits::into_visitor(),
-        )
-        .map(|bits| DecodedBits {
-            bits,
-            _marker: PhantomData,
-        });
+        let res =
+            scale_decode::visitor::decode_with_visitor(input, type_id, types, Bits::into_visitor())
+                .map(|bits| DecodedBits {
+                    bits,
+                    _marker: PhantomData,
+                });
         scale_decode::visitor::DecodeAsTypeResult::Decoded(res)
     }
 }
 impl<Store, Order> scale_decode::IntoVisitor for DecodedBits<Store, Order> {
-    type Visitor = DecodedBitsVisitor<Store, Order>;
-    fn into_visitor() -> Self::Visitor {
+    type AnyVisitor<R: scale_decode::TypeResolver> = DecodedBitsVisitor<Store, Order, R>;
+    fn into_visitor<R: TypeResolver>() -> DecodedBitsVisitor<Store, Order, R> {
         DecodedBitsVisitor(PhantomData)
     }
 }
 
 impl<Store, Order> scale_encode::EncodeAsType for DecodedBits<Store, Order> {
-    fn encode_as_type_to(
+    fn encode_as_type_to<R: TypeResolver>(
         &self,
-        type_id: u32,
-        types: &scale_info::PortableRegistry,
+        type_id: &R::TypeId,
+        types: &R,
         out: &mut Vec<u8>,
     ) -> Result<(), scale_encode::Error> {
         self.bits.encode_as_type_to(type_id, types, out)

subxt/src/utils/static_type.rs

@@ -3,7 +3,7 @@
 // see LICENSE for license details.
 
 use codec::{Decode, Encode};
-use scale_decode::{visitor::DecodeAsTypeResult, IntoVisitor, Visitor};
+use scale_decode::{visitor::DecodeAsTypeResult, IntoVisitor, TypeResolver, Visitor};
 use scale_encode::EncodeAsType;
 
 /// If the type inside this implements [`Encode`], this will implement [`scale_encode::EncodeAsType`].
@@ -18,10 +18,10 @@ use scale_encode::EncodeAsType;
 pub struct Static<T>(pub T);
 
 impl<T: Encode> EncodeAsType for Static<T> {
-    fn encode_as_type_to(
+    fn encode_as_type_to<R: TypeResolver>(
         &self,
-        _type_id: u32,
-        _types: &scale_decode::PortableRegistry,
+        _type_id: &R::TypeId,
+        _types: &R,
         out: &mut Vec<u8>,
     ) -> Result<(), scale_encode::Error> {
         self.0.encode_to(out);
@@ -29,17 +29,18 @@ impl<T: Encode> EncodeAsType for Static<T> {
     }
 }
 
-pub struct StaticDecodeAsTypeVisitor<T>(std::marker::PhantomData<T>);
+pub struct StaticDecodeAsTypeVisitor<T, R>(std::marker::PhantomData<(T, R)>);
 
-impl<T: Decode> Visitor for StaticDecodeAsTypeVisitor<T> {
+impl<T: Decode, R: TypeResolver> Visitor for StaticDecodeAsTypeVisitor<T, R> {
     type Value<'scale, 'info> = Static<T>;
     type Error = scale_decode::Error;
+    type TypeResolver = R;
 
     fn unchecked_decode_as_type<'scale, 'info>(
         self,
         input: &mut &'scale [u8],
-        _type_id: scale_decode::visitor::TypeId,
-        _types: &'info scale_info::PortableRegistry,
+        _type_id: &R::TypeId,
+        _types: &'info R,
     ) -> DecodeAsTypeResult<Self, Result<Self::Value<'scale, 'info>, Self::Error>> {
         use scale_decode::{visitor::DecodeError, Error};
         let decoded = T::decode(input)
@@ -50,8 +51,8 @@ impl<T: Decode> Visitor for StaticDecodeAsTypeVisitor<T> {
 }
 
 impl<T: Decode> IntoVisitor for Static<T> {
-    type Visitor = StaticDecodeAsTypeVisitor<T>;
-    fn into_visitor() -> Self::Visitor {
+    type AnyVisitor<R: TypeResolver> = StaticDecodeAsTypeVisitor<T, R>;
+    fn into_visitor<R: TypeResolver>() -> StaticDecodeAsTypeVisitor<T, R> {
         StaticDecodeAsTypeVisitor(std::marker::PhantomData)
     }
 }

subxt/src/utils/unchecked_extrinsic.rs

@@ -12,7 +12,7 @@
 use std::marker::PhantomData;
 
 use codec::{Decode, Encode};
-use scale_decode::{visitor::DecodeAsTypeResult, DecodeAsType, IntoVisitor, Visitor};
+use scale_decode::{visitor::DecodeAsTypeResult, DecodeAsType, IntoVisitor, TypeResolver, Visitor};
 
 use super::{Encoded, Static};
 
@@ -52,10 +52,10 @@ impl<Address, Call, Signature, Extra> Decode
 impl<Address, Call, Signature, Extra> scale_encode::EncodeAsType
     for UncheckedExtrinsic<Address, Call, Signature, Extra>
 {
-    fn encode_as_type_to(
+    fn encode_as_type_to<R: TypeResolver>(
         &self,
-        type_id: u32,
-        types: &scale_info::PortableRegistry,
+        type_id: &R::TypeId,
+        types: &R,
         out: &mut Vec<u8>,
     ) -> Result<(), scale_encode::Error> {
         self.0.encode_as_type_to(type_id, types, out)
@@ -78,32 +78,35 @@ impl<Address, Call, Signature, Extra> From<UncheckedExtrinsic<Address, Call, Sig
     }
 }
 
-pub struct UncheckedExtrinsicDecodeAsTypeVisitor<Address, Call, Signature, Extra>(
-    PhantomData<(Address, Call, Signature, Extra)>,
+pub struct UncheckedExtrinsicDecodeAsTypeVisitor<Address, Call, Signature, Extra, R: TypeResolver>(
+    PhantomData<(Address, Call, Signature, Extra, R)>,
 );
 
-impl<Address, Call, Signature, Extra> Visitor
-    for UncheckedExtrinsicDecodeAsTypeVisitor<Address, Call, Signature, Extra>
+impl<Address, Call, Signature, Extra, R: TypeResolver> Visitor
+    for UncheckedExtrinsicDecodeAsTypeVisitor<Address, Call, Signature, Extra, R>
 {
     type Value<'scale, 'info> = UncheckedExtrinsic<Address, Call, Signature, Extra>;
     type Error = scale_decode::Error;
+    type TypeResolver = R;
 
     fn unchecked_decode_as_type<'scale, 'info>(
         self,
         input: &mut &'scale [u8],
-        type_id: scale_decode::visitor::TypeId,
-        types: &'info scale_info::PortableRegistry,
+        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.0, types))
+        DecodeAsTypeResult::Decoded(Self::Value::decode_as_type(input, type_id, types))
     }
 }
 
 impl<Address, Call, Signature, Extra> IntoVisitor
     for UncheckedExtrinsic<Address, Call, Signature, Extra>
 {
-    type Visitor = UncheckedExtrinsicDecodeAsTypeVisitor<Address, Call, Signature, Extra>;
+    type AnyVisitor<R: TypeResolver> =
+        UncheckedExtrinsicDecodeAsTypeVisitor<Address, Call, Signature, Extra, R>;
 
-    fn into_visitor() -> Self::Visitor {
+    fn into_visitor<R: TypeResolver>(
+    ) -> UncheckedExtrinsicDecodeAsTypeVisitor<Address, Call, Signature, Extra, R> {
         UncheckedExtrinsicDecodeAsTypeVisitor(PhantomData)
     }
 }

subxt/src/utils/wrapper_opaque.rs

@@ -5,7 +5,7 @@
 use super::PhantomDataSendSync;
 use codec::{Compact, Decode, DecodeAll, Encode};
 use derivative::Derivative;
-use scale_decode::{IntoVisitor, Visitor};
+use scale_decode::{ext::scale_type_resolver::visitor, IntoVisitor, TypeResolver, Visitor};
 use scale_encode::EncodeAsType;
 
 /// A wrapper for any type `T` which implement encode/decode in a way compatible with `Vec<u8>`.
@@ -74,57 +74,47 @@ impl<T> WrapperKeepOpaque<T> {
 }
 
 impl<T> EncodeAsType for WrapperKeepOpaque<T> {
-    fn encode_as_type_to(
+    fn encode_as_type_to<R: TypeResolver>(
         &self,
-        type_id: u32,
-        types: &scale_info::PortableRegistry,
+        type_id: &R::TypeId,
+        types: &R,
         out: &mut Vec<u8>,
     ) -> Result<(), scale_encode::Error> {
         use scale_encode::error::{Error, ErrorKind, Kind};
 
-        let Some(ty) = types.resolve(type_id) else {
-            return Err(Error::new(ErrorKind::TypeNotFound(type_id)));
-        };
-
-        // Do a basic check that the target shape lines up.
-        let scale_info::TypeDef::Composite(_) = &ty.type_def else {
-            return Err(Error::new(ErrorKind::WrongShape {
+        let visitor = visitor::new(out, |_, _| {
+            // Check that the target shape lines up: any other shape but the composite is wrong.
+            Err(Error::new(ErrorKind::WrongShape {
                 actual: Kind::Struct,
-                expected: type_id,
-            }));
-        };
+                expected_id: format!("{:?}", type_id),
+            }))
+        })
+        .visit_composite(|out, _fields| {
+            self.data.encode_to(out);
+            Ok(())
+        });
 
-        // Check that the name also lines up.
-        if ty.path.ident().as_deref() != Some("WrapperKeepOpaque") {
-            return Err(Error::new(ErrorKind::WrongShape {
-                actual: Kind::Struct,
-                expected: type_id,
-            }));
-        }
-
-        // Just blat the bytes out.
-        self.data.encode_to(out);
-        Ok(())
+        types
+            .resolve_type(type_id, visitor)
+            .map_err(|_| Error::new(ErrorKind::TypeNotFound(format!("{:?}", type_id))))?
     }
 }
 
-pub struct WrapperKeepOpaqueVisitor<T>(std::marker::PhantomData<T>);
-impl<T> Visitor for WrapperKeepOpaqueVisitor<T> {
+pub struct WrapperKeepOpaqueVisitor<T, R>(std::marker::PhantomData<(T, R)>);
+impl<T, R: TypeResolver> Visitor for WrapperKeepOpaqueVisitor<T, R> {
     type Value<'scale, 'info> = WrapperKeepOpaque<T>;
     type Error = scale_decode::Error;
+    type TypeResolver = R;
 
     fn visit_composite<'scale, 'info>(
         self,
-        value: &mut scale_decode::visitor::types::Composite<'scale, 'info>,
-        _type_id: scale_decode::visitor::TypeId,
+        value: &mut scale_decode::visitor::types::Composite<'scale, 'info, R>,
+        _type_id: &R::TypeId,
     ) -> Result<Self::Value<'scale, 'info>, Self::Error> {
         use scale_decode::error::{Error, ErrorKind};
 
-        if value.path().ident().as_deref() != Some("WrapperKeepOpaque") {
-            return Err(Error::custom_str(
-                "Type to decode is not 'WrapperTypeKeepOpaque'",
-            ));
-        }
+        // 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.remaining() != 2 {
             return Err(Error::new(ErrorKind::WrongLength {
                 actual_len: value.remaining(),
@@ -151,8 +141,8 @@ impl<T> Visitor for WrapperKeepOpaqueVisitor<T> {
 }
 
 impl<T> IntoVisitor for WrapperKeepOpaque<T> {
-    type Visitor = WrapperKeepOpaqueVisitor<T>;
-    fn into_visitor() -> Self::Visitor {
+    type AnyVisitor<R: TypeResolver> = WrapperKeepOpaqueVisitor<T, R>;
+    fn into_visitor<R: TypeResolver>() -> WrapperKeepOpaqueVisitor<T, R> {
         WrapperKeepOpaqueVisitor(std::marker::PhantomData)
     }
 }
@@ -205,7 +195,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,
@@ -213,7 +203,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;