mirror of
https://github.com/pezkuwichain/pezkuwi-subxt.git
synced 2026-04-26 00:37:57 +00:00
James Wilson
c63ff6ec6d
* WIP EncodeAsType and DecodeAsType * remove silly cli experiment code * Get things finally compiling with EncodeAsType and DecodeAsType * update codegen test and WrapperKeepOpaque proper impl (in case it shows up in codegen) * fix tests * accomodate scale-value changes * starting to migrate to EncodeAsType/DecodeAsType * static event decoding and tx encoding to use DecodeAsFields/EncodeAsFields * some tidy up and add decode(skip) attrs where needed * fix root event decoding * #[codec(skip)] will do, and combine map_key stuff into storage_address since it's all specific to that * fmt and clippy * update Cargo.lock * remove patched scale-encode * bump scale-encode to 0.1 and remove unused dep in testing crate * update deps and use released scale-decode * update scale-value to latest to remove git branch * Apply suggestions from code review Co-authored-by: Alexandru Vasile <60601340+lexnv@users.noreply.github.com> * remove sorting in derives/attr generation; spit them out in order given * re-add derive sorting; it's a hashmap * StaticTxPayload and DynamicTxPayload rolled into single Payload struct * StaticStorageAddress and DynamicStorageAddress into single Address struct * Fix storage address byte retrieval * StaticConstantAddress and DynamicConstantAddress => Address * Simplify storage codegen to fix test * Add comments * Alias to RuntimeEvent rather than making another, and prep for substituting call type * remove unnecessary clone * Fix docs and failing UI test * root_bytes -> to_root_bytes * document error case in StorageClient::address_bytes() --------- Co-authored-by: Alexandru Vasile <60601340+lexnv@users.noreply.github.com>
82 lines
2.4 KiB
Rust
82 lines
2.4 KiB
Rust
// Copyright 2019-2022 Parity Technologies (UK) Ltd.
|
|
// This file is dual-licensed as Apache-2.0 or GPL-3.0.
|
|
// see LICENSE for license details.
|
|
|
|
//! This module provides the entry points to create dynamic
|
|
//! transactions, storage and constant lookups.
|
|
|
|
use crate::{
|
|
error::Error,
|
|
metadata::{
|
|
DecodeWithMetadata,
|
|
Metadata,
|
|
},
|
|
};
|
|
use scale_decode::DecodeAsType;
|
|
|
|
pub use scale_value::Value;
|
|
|
|
/// A [`scale_value::Value`] type endowed with contextual information
|
|
/// regarding what type was used to decode each part of it. This implements
|
|
/// [`crate::metadata::DecodeWithMetadata`], and is used as a return type
|
|
/// for dynamic requests.
|
|
pub type DecodedValue = scale_value::Value<scale_value::scale::TypeId>;
|
|
|
|
// Submit dynamic transactions.
|
|
pub use crate::tx::dynamic as tx;
|
|
|
|
// Lookup constants dynamically.
|
|
pub use crate::constants::dynamic as constant;
|
|
|
|
// Lookup storage values dynamically.
|
|
pub use crate::storage::{
|
|
dynamic as storage,
|
|
dynamic_root as storage_root,
|
|
};
|
|
|
|
/// This is the result of making a dynamic request to a node. From this,
|
|
/// we can return the raw SCALE bytes that we were handed back, or we can
|
|
/// complete the decoding of the bytes into a [`DecodedValue`] type.
|
|
pub struct DecodedValueThunk {
|
|
type_id: u32,
|
|
metadata: Metadata,
|
|
scale_bytes: Vec<u8>,
|
|
}
|
|
|
|
impl DecodeWithMetadata for DecodedValueThunk {
|
|
fn decode_with_metadata(
|
|
bytes: &mut &[u8],
|
|
type_id: u32,
|
|
metadata: &Metadata,
|
|
) -> Result<Self, Error> {
|
|
let mut v = Vec::with_capacity(bytes.len());
|
|
v.extend_from_slice(bytes);
|
|
*bytes = &[];
|
|
Ok(DecodedValueThunk {
|
|
type_id,
|
|
metadata: metadata.clone(),
|
|
scale_bytes: v,
|
|
})
|
|
}
|
|
}
|
|
|
|
impl DecodedValueThunk {
|
|
/// Return the SCALE encoded bytes handed back from the node.
|
|
pub fn into_encoded(self) -> Vec<u8> {
|
|
self.scale_bytes
|
|
}
|
|
/// Return the SCALE encoded bytes handed back from the node without taking ownership of them.
|
|
pub fn encoded(&self) -> &[u8] {
|
|
&self.scale_bytes
|
|
}
|
|
/// Decode the SCALE encoded storage entry into a dynamic [`DecodedValue`] type.
|
|
pub fn to_value(&self) -> Result<DecodedValue, Error> {
|
|
let val = DecodedValue::decode_as_type(
|
|
&mut &*self.scale_bytes,
|
|
self.type_id,
|
|
self.metadata.types(),
|
|
)?;
|
|
Ok(val)
|
|
}
|
|
}
|