@dashevo/wasm-dpp 0.25.0-dev.8 → 0.25.0

package/src/data_contract/data_contract.rs

@@ -1,353 +1,463 @@
 #![allow(clippy::from_over_into)]
 
 use std::collections::BTreeMap;
-use std::convert::{TryFrom, TryInto};
+use std::convert::TryFrom;
 
 pub use serde::{Deserialize, Serialize};
-use serde_json::Value as JsonValue;
 use wasm_bindgen::prelude::*;
 
-use dpp::data_contract::{DataContract, SCHEMA_URI};
-use dpp::platform_value::string_encoding::Encoding;
-use dpp::platform_value::{Bytes32, Value};
+use dpp::data_contract::schema::DataContractSchemaMethodsV0;
+use dpp::data_contract::{DataContract, DocumentName, JsonValue};
+use dpp::platform_value::{platform_value, Bytes32, Value};
+
+use dpp::data_contract::accessors::v0::{DataContractV0Getters, DataContractV0Setters};
+use dpp::data_contract::config::DataContractConfig;
+use dpp::data_contract::conversion::json::DataContractJsonConversionMethodsV0;
+use dpp::data_contract::conversion::value::v0::DataContractValueConversionMethodsV0;
+use dpp::data_contract::created_data_contract::CreatedDataContract;
+use dpp::data_contract::document_type::accessors::DocumentTypeV0Getters;
+use dpp::data_contract::serialized_version::DataContractInSerializationFormat;
+use dpp::serialization::{PlatformSerializable, PlatformSerializableWithPlatformVersion};
+use dpp::version::PlatformVersion;
+use dpp::{platform_value, ProtocolError};
 
-use dpp::{platform_value, Convertible};
-
-use crate::errors::RustConversionError;
 use crate::identifier::identifier_from_js_value;
 use crate::metadata::MetadataWasm;
-use crate::utils::{IntoWasm, WithJsError};
-use crate::{bail_js, with_js_error};
+use crate::utils::get_bool_from_options;
+use crate::utils::SKIP_VALIDATION_PROPERTY_NAME;
+use crate::utils::{Inner, IntoWasm, ToSerdeJSONExt, WithJsError};
+use crate::{bail_js, console_log, with_js_error};
 use crate::{buffer::Buffer, identifier::IdentifierWrapper};
 
 #[wasm_bindgen(js_name=DataContract)]
 #[derive(Debug, Clone)]
-pub struct DataContractWasm(pub(crate) DataContract);
+pub struct DataContractWasm {
+    inner: DataContract,
+    entropy_used: Option<Vec<u8>>,
+}
 
-impl std::convert::From<DataContract> for DataContractWasm {
-    fn from(v: DataContract) -> Self {
-        DataContractWasm(v)
+/// CreatedDataContract contains entropy and is used to create
+/// DataContractCreateTransition
+impl From<CreatedDataContract> for DataContractWasm {
+    fn from(v: CreatedDataContract) -> Self {
+        DataContractWasm {
+            inner: v.data_contract().clone(),
+            entropy_used: Some(v.entropy_used().to_vec()),
+        }
     }
 }
 
-impl std::convert::From<&DataContractWasm> for DataContract {
-    fn from(v: &DataContractWasm) -> Self {
-        v.0.clone()
+/// Regular DataContract does not contain entropy and is used
+/// in DataContractUpdateTransition
+impl From<DataContract> for DataContractWasm {
+    fn from(v: DataContract) -> Self {
+        DataContractWasm {
+            inner: v,
+            entropy_used: None,
+        }
     }
 }
 
-impl std::convert::Into<DataContract> for DataContractWasm {
-    fn into(self) -> DataContract {
-        self.0
+impl From<&DataContractWasm> for DataContract {
+    fn from(v: &DataContractWasm) -> Self {
+        v.inner.clone()
     }
 }
 
-#[derive(Debug, Serialize, Deserialize)]
-#[serde(rename_all = "camelCase")]
-pub(crate) struct DataContractParameters {
-    #[serde(
-        rename = "$schema",
-        skip_serializing_if = "serde_json::Value::is_null",
-        default
-    )]
-    schema: serde_json::Value,
-    #[serde(rename = "$id", skip_serializing_if = "Option::is_none")]
-    id: Option<Vec<u8>>,
-    #[serde(skip_serializing_if = "Option::is_none")]
-    owner_id: Option<Vec<u8>>,
-    #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
-    documents: serde_json::Value,
-    #[serde(
-        skip_serializing_if = "serde_json::Value::is_null",
-        default,
-        rename = "$defs"
-    )]
-    defs: serde_json::Value,
-    #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
-    protocol_version: serde_json::Value,
-    #[serde(skip_serializing_if = "serde_json::Value::is_null", default)]
-    version: serde_json::Value,
-
-    #[serde(flatten)]
-    _extras: serde_json::Value, // Captures excess fields to trigger validation failure later.
-}
+impl TryFrom<&DataContractWasm> for CreatedDataContract {
+    type Error = ProtocolError;
+    fn try_from(v: &DataContractWasm) -> Result<Self, Self::Error> {
+        let entropy = if let Some(entropy_used) = &v.entropy_used {
+            Bytes32::from_vec(entropy_used.to_owned())?
+        } else {
+            Bytes32::default()
+        };
 
-pub fn js_value_to_data_contract_value(object: JsValue) -> Result<Value, JsValue> {
-    let parameters: DataContractParameters =
-        with_js_error!(serde_wasm_bindgen::from_value(object))?;
+        let platform_version = PlatformVersion::first();
 
-    platform_value::to_value(parameters).map_err(|e| e.to_string().into())
+        CreatedDataContract::from_contract_and_entropy(
+            v.to_owned().into(),
+            entropy,
+            platform_version,
+        )
+    }
+}
+
+impl Into<DataContract> for DataContractWasm {
+    fn into(self) -> DataContract {
+        self.inner
+    }
 }
 
 #[wasm_bindgen(js_class=DataContract)]
 impl DataContractWasm {
     #[wasm_bindgen(constructor)]
-    pub fn new(raw_parameters: JsValue) -> Result<DataContractWasm, JsValue> {
-        let parameters: DataContractParameters =
-            with_js_error!(serde_wasm_bindgen::from_value(raw_parameters))?;
+    pub fn new(
+        raw_parameters: JsValue,
+        options: Option<js_sys::Object>,
+    ) -> Result<DataContractWasm, JsValue> {
+        let skip_validation = if let Some(opts) = options {
+            get_bool_from_options(opts.into(), SKIP_VALIDATION_PROPERTY_NAME, false)?
+        } else {
+            false
+        };
+
+        let platform_version = PlatformVersion::first();
 
-        DataContract::from_raw_object(
-            platform_value::to_value(parameters).expect("Implements Serialize"),
+        DataContract::from_value(
+            raw_parameters.with_serde_to_platform_value()?,
+            !skip_validation,
+            platform_version,
         )
         .with_js_error()
         .map(Into::into)
     }
 
-    #[wasm_bindgen(js_name=getProtocolVersion)]
-    pub fn get_protocol_version(&self) -> u32 {
-        self.0.protocol_version
-    }
-
     #[wasm_bindgen(js_name=getId)]
-    pub fn get_id(&self) -> IdentifierWrapper {
-        self.0.id.into()
+    pub fn id(&self) -> IdentifierWrapper {
+        self.inner.id().into()
     }
 
     #[wasm_bindgen(js_name=setId)]
     pub fn set_id(&mut self, id: &JsValue) -> Result<(), JsValue> {
         let id = identifier_from_js_value(id)?;
-        self.0.id = id;
+
+        self.inner.set_id(id);
+
         Ok(())
     }
 
     #[wasm_bindgen(js_name=getOwnerId)]
-    pub fn get_owner_id(&self) -> IdentifierWrapper {
-        self.0.owner_id.into()
+    pub fn owner_id(&self) -> IdentifierWrapper {
+        self.inner.owner_id().into()
     }
 
     #[wasm_bindgen(js_name=getVersion)]
-    pub fn get_version(&self) -> u32 {
-        self.0.version
+    pub fn version(&self) -> u32 {
+        self.inner.version()
     }
 
     #[wasm_bindgen(js_name=setVersion)]
     pub fn set_version(&mut self, v: u32) {
-        self.0.version = v;
+        self.inner.set_version(v);
     }
 
     #[wasm_bindgen(js_name=incrementVersion)]
     pub fn increment_version(&mut self) {
-        self.0.increment_version()
+        self.inner.increment_version()
     }
 
-    #[wasm_bindgen(js_name=getJsonSchemaId)]
-    pub fn get_json_schema_id(&self) -> String {
-        self.0.id.to_string(Encoding::Base58)
-    }
+    #[wasm_bindgen(js_name=getBinaryProperties)]
+    pub fn get_binary_properties(&self, doc_type: &str) -> Result<JsValue, JsValue> {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
 
-    #[wasm_bindgen(js_name=setJsonMetaSchema)]
-    pub fn set_json_meta_schema(&mut self, schema: String) {
-        self.0.schema = schema;
-    }
+        let document_type = self
+            .inner
+            .document_type_for_name(doc_type)
+            .with_js_error()?;
+
+        let binary_paths_o = document_type.binary_paths();
+
+        let mut binary_paths = BTreeMap::new();
+
+        document_type.binary_paths().iter().for_each(
+            (|path| {
+                binary_paths.insert(path.to_owned(), platform_value!({}));
+            }),
+        );
 
-    #[wasm_bindgen(js_name=getJsonMetaSchema)]
-    pub fn get_json_meta_schema(&self) -> String {
-        self.0.schema.clone()
+        document_type.identifier_paths().iter().for_each(
+            (|path| {
+                binary_paths.insert(
+                    path.to_owned(),
+                    platform_value!({
+                        "contentMediaType": "application/x.dash.dpp.identifier"
+                    }),
+                );
+            }),
+        );
+
+        with_js_error!(binary_paths.serialize(&serializer))
     }
-    #[wasm_bindgen(js_name=setDocuments)]
-    pub fn set_documents(&mut self, documents: JsValue) -> Result<(), JsValue> {
-        let json_value: JsonValue = with_js_error!(serde_wasm_bindgen::from_value(documents))?;
 
-        let mut docs: BTreeMap<String, JsonValue> = BTreeMap::new();
-        if let JsonValue::Object(o) = json_value {
-            for (k, v) in o.into_iter() {
-                if !v.is_object() {
-                    bail_js!("is not an object")
-                }
-                docs.insert(k, v);
-            }
-            self.0.documents = docs;
+    #[wasm_bindgen(js_name=setDocumentSchemas)]
+    pub fn set_document_schemas(
+        &mut self,
+        schemas: JsValue,
+        options: Option<js_sys::Object>,
+    ) -> Result<(), JsValue> {
+        let (skip_validation, defs) = if let Some(opts) = options {
+            let opts_value = opts.with_serde_to_platform_value()?;
+
+            (
+                get_bool_from_options(opts.into(), SKIP_VALIDATION_PROPERTY_NAME, false)?,
+                opts_value
+                    .get_optional_value("defs")
+                    .map_err(JsError::from)?
+                    .map(|defs| defs.clone().into_btree_string_map())
+                    .transpose()
+                    .map_err(JsError::from)?,
+            )
         } else {
-            bail_js!("the parameter 'documents' is not an JS object")
-        }
-        Ok(())
-    }
+            (false, None)
+        };
 
-    #[wasm_bindgen(js_name=getDocuments)]
-    pub fn get_documents(&self) -> Result<JsValue, JsValue> {
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        with_js_error!(self.0.documents.serialize(&serializer))
-    }
+        let document_schemas: Value = schemas.with_serde_to_platform_value()?;
+        let document_schemas_map = document_schemas
+            .into_btree_string_map()
+            .map_err(JsError::from)?;
+
+        let platform_version = PlatformVersion::first();
 
-    #[wasm_bindgen(js_name=isDocumentDefined)]
-    pub fn is_document_defined(&self, doc_type: String) -> bool {
-        self.0.is_document_defined(&doc_type)
+        self.inner
+            .set_document_schemas(
+                document_schemas_map,
+                defs,
+                !skip_validation,
+                &platform_version,
+            )
+            .with_js_error()
     }
 
     #[wasm_bindgen(js_name=setDocumentSchema)]
     pub fn set_document_schema(
         &mut self,
-        doc_type: String,
+        name: &str,
         schema: JsValue,
+        options: Option<js_sys::Object>,
     ) -> Result<(), JsValue> {
-        let json_schema: JsonValue = with_js_error!(serde_wasm_bindgen::from_value(schema))?;
-        self.0
-            .set_document_schema(doc_type, json_schema)
-            .with_js_error()?;
-        Ok(())
+        let (skip_validation) = if let Some(options) = options {
+            get_bool_from_options(options.into(), SKIP_VALIDATION_PROPERTY_NAME, false)?
+        } else {
+            false
+        };
+
+        let schema_value: Value = schema.with_serde_to_platform_value()?;
+
+        let platform_version = PlatformVersion::first();
+
+        self.inner
+            .set_document_schema(name, schema_value, !skip_validation, &platform_version)
+            .with_js_error()
     }
 
     #[wasm_bindgen(js_name=getDocumentSchema)]
-    pub fn get_document_schema(&mut self, doc_type: &str) -> Result<JsValue, JsValue> {
-        let doc_schema = self.0.get_document_schema(doc_type).with_js_error()?;
+    pub fn document_schema(&mut self, name: &str) -> Result<JsValue, JsValue> {
+        let document_type = self.inner.document_type_for_name(name).with_js_error()?;
+
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        document_type
+            .schema()
+            .serialize(&serializer)
+            .map_err(JsError::from)
+            .map_err(Into::into)
+    }
+
+    #[wasm_bindgen(js_name=getDocumentSchemas)]
+    pub fn document_schemas(&self) -> JsValue {
+        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
+        self.inner
+            .document_schemas()
+            .serialize(&serializer)
+            .expect("document schemas defs to js value")
+    }
+
+    #[wasm_bindgen(js_name=getSchemaDefs)]
+    pub fn schema_defs(&self) -> JsValue {
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        with_js_error!(doc_schema.serialize(&serializer))
-    }
-
-    #[wasm_bindgen(js_name=getDocumentSchemaRef)]
-    pub fn get_document_schema_ref(&self, doc_type: &str) -> Result<JsValue, JsValue> {
-        with_js_error!(serde_wasm_bindgen::to_value(
-            &self.0.get_document_schema_ref(doc_type).with_js_error()?
-        ))
-    }
-
-    #[wasm_bindgen(js_name=setDefinitions)]
-    pub fn set_definitions(&mut self, definitions: JsValue) -> Result<(), JsValue> {
-        let json_value: JsonValue = with_js_error!(serde_wasm_bindgen::from_value(definitions))?;
-        let mut definitions: BTreeMap<String, JsonValue> = BTreeMap::new();
-        if let JsonValue::Object(o) = json_value {
-            for (k, v) in o.into_iter() {
-                // v must be a Object
-                if !v.is_object() {
-                    bail_js!("{:?} is not an object", v);
-                }
-                definitions.insert(k, v);
-            }
-            if definitions.is_empty() {
-                bail_js!("`definitions` cannot be empty");
-            }
-            self.0.defs = Some(definitions);
+
+        self.inner
+            .schema_defs()
+            .serialize(&serializer)
+            .expect("document schemas defs to js value")
+    }
+
+    #[wasm_bindgen(js_name=setSchemaDefs)]
+    pub fn set_schema_defs(
+        &mut self,
+        defs: Option<js_sys::Object>,
+        options: Option<js_sys::Object>,
+    ) -> Result<(), JsValue> {
+        let (skip_validation) = if let Some(options) = options {
+            get_bool_from_options(options.into(), SKIP_VALIDATION_PROPERTY_NAME, false)?
         } else {
-            bail_js!("the parameter 'definitions' is not an JS object");
-        }
+            false
+        };
+
+        let platform_version = PlatformVersion::first();
+
+        let maybe_schema_defs = defs
+            .map(|js_value| serde_wasm_bindgen::from_value(js_value.into()))
+            .transpose()?;
+
+        self.inner
+            .set_schema_defs(maybe_schema_defs, !skip_validation, platform_version)
+            .with_js_error()?;
+
         Ok(())
     }
 
-    #[wasm_bindgen(js_name=getDefinitions)]
-    pub fn get_definitions(&self) -> Result<JsValue, JsValue> {
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        with_js_error!(self.0.defs.serialize(&serializer))
+    #[wasm_bindgen(js_name=hasDocumentType)]
+    pub fn has_document_type(&self, doc_type: String) -> bool {
+        self.inner.has_document_type_for_name(&doc_type)
     }
 
     #[wasm_bindgen(js_name=setEntropy)]
     pub fn set_entropy(&mut self, e: Vec<u8>) -> Result<(), JsValue> {
-        let entropy: [u8; 32] = e.try_into().map_err(|_| {
-            RustConversionError::Error(String::from(
-                "unable to turn the data into 32 bytes array of bytes",
-            ))
-            .to_js_value()
-        })?;
-        self.0.entropy = Bytes32::new(entropy);
+        self.entropy_used = Some(e);
         Ok(())
     }
 
     #[wasm_bindgen(js_name=getEntropy)]
-    pub fn get_entropy(&mut self) -> Buffer {
-        Buffer::from_bytes_owned(self.0.entropy.to_vec())
-    }
-
-    #[wasm_bindgen(js_name=getBinaryProperties)]
-    pub fn get_binary_properties(&self, doc_type: &str) -> Result<JsValue, JsValue> {
-        let serializer = serde_wasm_bindgen::Serializer::json_compatible();
-        with_js_error!(self
-            .0
-            .get_binary_properties(doc_type)
-            .with_js_error()?
-            .serialize(&serializer))
+    pub fn entropy(&mut self) -> JsValue {
+        self.entropy_used
+            .as_ref()
+            .map(|e| Buffer::from_bytes(e.as_slice()).into())
+            .unwrap_or(JsValue::undefined())
     }
 
     #[wasm_bindgen(js_name=getMetadata)]
-    pub fn get_metadata(&self) -> Option<MetadataWasm> {
-        self.0.metadata.clone().map(Into::into)
+    pub fn metadata(&self) -> Option<MetadataWasm> {
+        self.inner.metadata().cloned().map(Into::into)
     }
 
     #[wasm_bindgen(js_name=setMetadata)]
     pub fn set_metadata(&mut self, metadata: JsValue) -> Result<(), JsValue> {
-        self.0.metadata = if !metadata.is_falsy() {
+        let metadata = if !metadata.is_falsy() {
             let metadata = metadata.to_wasm::<MetadataWasm>("Metadata")?;
             Some(metadata.to_owned().into())
         } else {
             None
         };
 
+        self.inner.set_metadata(metadata);
+
         Ok(())
     }
 
     #[wasm_bindgen(js_name=toObject)]
     pub fn to_object(&self) -> Result<JsValue, JsValue> {
-        let value = self.0.to_cleaned_object().with_js_error()?;
+        let platform_version = PlatformVersion::first();
+
+        let value = self.inner.to_value(platform_version).with_js_error()?;
+
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
+
         let object = with_js_error!(value.serialize(&serializer))?;
 
         js_sys::Reflect::set(
             &object,
-            &Into::<JsValue>::into("$id".to_owned()),
-            &Into::<JsValue>::into(Buffer::from_bytes_owned(self.0.id.to_vec())),
+            &Into::<JsValue>::into("id".to_owned()),
+            &Into::<JsValue>::into(Buffer::from_bytes_owned(self.inner.id().to_vec())),
         )
         .expect("target is an object");
         js_sys::Reflect::set(
             &object,
             &Into::<JsValue>::into("ownerId".to_owned()),
-            &Into::<JsValue>::into(Buffer::from_bytes_owned(self.0.owner_id.to_vec())),
+            &Into::<JsValue>::into(Buffer::from_bytes_owned(self.inner.owner_id().to_vec())),
         )
         .expect("target is an object");
         Ok(object)
     }
 
+    #[wasm_bindgen(js_name=getConfig)]
+    pub fn config(&self) -> Result<JsValue, JsValue> {
+        Ok(serde_wasm_bindgen::to_value(&self.inner.config())?)
+    }
+
+    #[wasm_bindgen(js_name=setConfig)]
+    pub fn set_config(&mut self, config: JsValue) -> Result<(), JsValue> {
+        let value = config.with_serde_to_platform_value()?;
+
+        let platform_version = &PlatformVersion::first();
+
+        let data_contract_config =
+            DataContractConfig::from_value(value, platform_version).with_js_error()?;
+
+        self.inner.set_config(data_contract_config);
+
+        Ok(())
+    }
+
     #[wasm_bindgen(js_name=toJSON)]
     pub fn to_json(&self) -> Result<JsValue, JsValue> {
-        let json = self.0.to_json().with_js_error()?;
+        let platform_version = PlatformVersion::first();
+
+        let json = self.inner.to_json(platform_version).with_js_error()?;
         let serializer = serde_wasm_bindgen::Serializer::json_compatible();
         with_js_error!(json.serialize(&serializer))
     }
 
     #[wasm_bindgen(js_name=toBuffer)]
     pub fn to_buffer(&self) -> Result<Buffer, JsValue> {
-        let bytes = self.0.to_cbor_buffer().with_js_error()?;
+        let platform_version = PlatformVersion::first();
+
+        let bytes = self
+            .inner
+            .serialize_to_bytes_with_platform_version(platform_version)
+            .with_js_error()?;
+
         Ok(Buffer::from_bytes(&bytes))
     }
 
     #[wasm_bindgen(js_name=hash)]
     pub fn hash(&self) -> Result<Vec<u8>, JsValue> {
-        self.0.hash().with_js_error()
-    }
+        let platform_version = PlatformVersion::first();
 
-    #[wasm_bindgen(js_name=from)]
-    pub fn from_js_value(v: JsValue) -> Result<DataContractWasm, JsValue> {
-        let json_contract: JsonValue = with_js_error!(serde_wasm_bindgen::from_value(v))?;
-        Ok(DataContract::try_from(json_contract)
-            .with_js_error()?
-            .into())
+        self.inner.hash(platform_version).with_js_error()
     }
 
-    #[wasm_bindgen(js_name=fromBuffer)]
-    pub fn from_buffer(b: &[u8]) -> Result<DataContractWasm, JsValue> {
-        let data_contract = DataContract::from_cbor(b).with_js_error()?;
-        Ok(data_contract.into())
-    }
+    // #[wasm_bindgen(js_name=from)]
+    // pub fn from_js_value(v: JsValue) -> Result<DataContractWasm, JsValue> {
+    //     let json_contract: JsonValue = with_js_error!(serde_wasm_bindgen::from_value(v))?;
+    //     Ok(DataContract::try_from(json_contract)
+    //         .with_js_error()?
+    //         .into())
+    // }
+
+    // #[wasm_bindgen(js_name=fromBuffer)]
+    // pub fn from_buffer(b: &[u8]) -> Result<DataContractWasm, JsValue> {
+    //     let data_contract = DataContract::from_cbor(b).with_js_error()?;
+    //     Ok(data_contract.into())
+    // }
 
     #[wasm_bindgen(js_name=clone)]
     pub fn deep_clone(&self) -> Self {
         self.clone()
     }
+
+    pub(crate) fn try_from_serialization_format(
+        value: DataContractInSerializationFormat,
+        validate: bool,
+    ) -> Result<Self, JsValue> {
+        let platform_version = PlatformVersion::first();
+
+        DataContract::try_from_platform_versioned(value, validate, platform_version)
+            .with_js_error()
+            .map(Into::into)
+    }
 }
 
-#[wasm_bindgen(js_name=DataContractDefaults)]
-pub struct DataContractDefaults;
+impl Inner for DataContractWasm {
+    type InnerItem = DataContract;
+
+    fn into_inner(self) -> DataContract {
+        self.inner
+    }
+
+    fn inner(&self) -> &DataContract {
+        &self.inner
+    }
 
-#[wasm_bindgen(js_class=DataContractDefaults)]
-impl DataContractDefaults {
-    #[wasm_bindgen(getter = SCHEMA)]
-    pub fn get_default_schema() -> String {
-        SCHEMA_URI.to_string()
+    fn inner_mut(&mut self) -> &mut DataContract {
+        &mut self.inner
     }
 }
 
 impl DataContractWasm {
     pub fn inner(&self) -> &DataContract {
-        &self.0
+        &self.inner
     }
 }
-
-#[test]
-fn test_query_many() {}