constants and storage entries

subxt/src/storage/storage_type.rs

@@ -289,65 +289,3 @@ where
         })
     }
 }
-
-/// Validate a storage address against the metadata.
-pub(crate) fn validate_storage_address<Address: StorageAddress>(
-    address: &Address,
-    pallet: PalletMetadata<'_>,
-) -> Result<(), Error> {
-    if let Some(hash) = address.validation_hash() {
-        validate_storage(pallet, address.entry_name(), hash)?;
-    }
-    Ok(())
-}
-
-/// Return details about the given storage entry.
-fn lookup_entry_details<'a>(
-    pallet_name: &str,
-    entry_name: &str,
-    metadata: &'a Metadata,
-) -> Result<(PalletMetadata<'a>, &'a StorageEntryMetadata), Error> {
-    let pallet_metadata = metadata.pallet_by_name_err(pallet_name)?;
-    let storage_metadata = pallet_metadata
-        .storage()
-        .ok_or_else(|| MetadataError::StorageNotFoundInPallet(pallet_name.to_owned()))?;
-    let storage_entry = storage_metadata
-        .entry_by_name(entry_name)
-        .ok_or_else(|| MetadataError::StorageEntryNotFound(entry_name.to_owned()))?;
-    Ok((pallet_metadata, storage_entry))
-}
-
-/// Validate a storage entry against the metadata.
-fn validate_storage(
-    pallet: PalletMetadata<'_>,
-    storage_name: &str,
-    hash: [u8; 32],
-) -> Result<(), Error> {
-    let Some(expected_hash) = pallet.storage_hash(storage_name) else {
-        return Err(MetadataError::IncompatibleCodegen.into());
-    };
-    if expected_hash != hash {
-        return Err(MetadataError::IncompatibleCodegen.into());
-    }
-    Ok(())
-}
-
-/// Fetch the return type out of a [`StorageEntryType`].
-fn return_type_from_storage_entry_type(entry: &StorageEntryType) -> u32 {
-    match entry {
-        StorageEntryType::Plain(ty) => *ty,
-        StorageEntryType::Map { value_ty, .. } => *value_ty,
-    }
-}
-
-/// Given some bytes, a pallet and storage name, decode the response.
-fn decode_storage_with_metadata<T: DecodeWithMetadata>(
-    bytes: &mut &[u8],
-    metadata: &Metadata,
-    storage_metadata: &StorageEntryMetadata,
-) -> Result<T, Error> {
-    let ty = storage_metadata.entry_type();
-    let return_ty = return_type_from_storage_entry_type(ty);
-    let val = T::decode_with_metadata(bytes, return_ty, metadata)?;
-    Ok(val)
-}