persistence: add access to type system

Author: dr-orlovsky

src/persistence/stash.rs

@@ -304,7 +304,15 @@ impl<P: StashProvider> Stash<P> {
         Ok(Scripts::from_checked(scripts))
     }
 
-    pub(super) fn extract<'a>(
+    pub(super) fn type_system(&self, iface: &Iface) -> Result<TypeSystem, StashError<P>> {
+        Ok(self
+            .provider
+            .type_system()
+            .map_err(StashError::ReadProvider)?
+            .extract(iface.types())?)
+    }
+
+    pub(super) fn types_scripts<'a>(
         &self,
         schema: &Schema,
         ifaces: impl IntoIterator<Item = &'a Iface>,
@@ -344,7 +352,7 @@ impl<P: StashProvider> Stash<P> {
             .get(iface_id)
             .ok_or(StashDataError::NoIfaceImpl(schema_id, iface_id))?;
 
-        let (types, scripts) = self.extract(&schema_ifaces.schema, [iface])?;
+        let (types, scripts) = self.types_scripts(&schema_ifaces.schema, [iface])?;
 
         let builder = ContractBuilder::with(
             issuer,
@@ -370,7 +378,7 @@ impl<P: StashProvider> Stash<P> {
             .get(iface.iface_id())
             .ok_or(StashDataError::NoIfaceImpl(schema.schema_id(), iface.iface_id()))?;
 
-        let (types, _) = self.extract(&schema_ifaces.schema, [iface])?;
+        let types = self.type_system(iface)?;
         let scripts = self.scripts(iimpl.state_abi.lib_ids())?;
 
         let builder = if let Some(transition_name) = transition_name {
@@ -409,7 +417,7 @@ impl<P: StashProvider> Stash<P> {
         if schema_ifaces.iimpls.is_empty() {
             return Err(StashDataError::NoIfaceImpl(schema.schema_id(), iface.iface_id()).into());
         }
-        let (types, _) = self.extract(&schema_ifaces.schema, [iface])?;
+        let types = self.type_system(iface)?;
 
         let builder = if let Some(iimpl) = schema_ifaces.get(iface.iface_id()) {
             TransitionBuilder::blank_transition(

src/persistence/stock.rs

@@ -39,6 +39,7 @@ use rgb::{
     SchemaId, SecretSeal, Transition, TxoSeal, XChain, XOutpoint, XOutputSeal, XWitnessId,
 };
 use strict_encoding::FieldName;
+use strict_types::TypeSystem;
 
 use super::{
     ContractStateRead, Index, IndexError, IndexInconsistency, IndexProvider, IndexReadProvider,
@@ -494,6 +495,9 @@ impl<S: StashProvider, H: StateProvider, P: IndexProvider> Stock<S, H, P> {
     pub fn iface(&self, iface: impl Into<IfaceRef>) -> Result<&Iface, StockError<S, H, P>> {
         Ok(self.stash.iface(iface)?)
     }
+    pub fn type_system(&self, iface: &Iface) -> Result<TypeSystem, StockError<S, H, P>> {
+        Ok(self.stash.type_system(iface)?)
+    }
     pub fn schemata(&self) -> Result<impl Iterator<Item = SchemaInfo> + '_, StockError<S, H, P>> {
         Ok(self.stash.schemata()?.map(SchemaInfo::with))
     }
@@ -573,7 +577,7 @@ impl<S: StashProvider, H: StateProvider, P: IndexProvider> Stock<S, H, P> {
         let iimpl = self.stash.impl_for::<C>(schema_ifaces)?;
 
         let iface = self.stash.iface(iimpl.iface_id)?;
-        let (types, _) = self.stash.extract(&schema_ifaces.schema, [iface])?;
+        let types = self.stash.type_system(iface)?;
 
         Ok(C::Wrapper::with(ContractIface {
             state,
@@ -599,7 +603,7 @@ impl<S: StashProvider, H: StateProvider, P: IndexProvider> Stock<S, H, P> {
             ContractIfaceError::NoAbstractImpl(iface_id, schema_ifaces.schema.schema_id())
         })?;
 
-        let (types, _) = self.stash.extract(&schema_ifaces.schema, [iface])?;
+        let types = self.stash.type_system(iface)?;
 
         Ok(ContractIface {
             state,
@@ -678,7 +682,9 @@ impl<S: StashProvider, H: StateProvider, P: IndexProvider> Stock<S, H, P> {
         kit.iimpls
             .extend(schema_ifaces.iimpls.values().cloned())
             .expect("type guarantees");
-        let (types, scripts) = self.stash.extract(&schema_ifaces.schema, &kit.ifaces)?;
+        let (types, scripts) = self
+            .stash
+            .types_scripts(&schema_ifaces.schema, &kit.ifaces)?;
         kit.scripts
             .extend(scripts.into_values())
             .expect("type guarantees");
@@ -843,7 +849,9 @@ impl<S: StashProvider, H: StateProvider, P: IndexProvider> Stock<S, H, P> {
         let terminals =
             Confined::try_from(terminals).map_err(|_| ConsignError::TooManyTerminals)?;
 
-        let (types, scripts) = self.stash.extract(&schema_ifaces.schema, ifaces.keys())?;
+        let (types, scripts) = self
+            .stash
+            .types_scripts(&schema_ifaces.schema, ifaces.keys())?;
         let scripts = Confined::from_iter_checked(scripts.into_values());
         let supplements =
             Confined::try_from(supplements).map_err(|_| ConsignError::TooManySupplements)?;