pub struct Schema { /* private fields */ }Expand description
A schema, representing set of types (i.e. rust code) as a data structure. The schema allows any included type’s borsh serialization to be displayed as a human readable string, and the type’s JSON serialisation to be re-serialised to borsh without depending on the original Rust type. It is also serialisable and therefore, once generated for a rollup, can be imported and used with non-Rust languages, enabling toolkits in any language to implement the same functionality as above.
A schema can be instantiated for any type that implements either UniversalWallet or
OverrideSchema. In turn, UniversalWallet is intended to be automatically derived using the
UniversalWallet macro.
Implementations§
Source§impl Schema
impl Schema
Sourcepub fn of_single_type<T>() -> Result<Schema, SchemaError>where
T: UniversalWallet,
pub fn of_single_type<T>() -> Result<Schema, SchemaError>where
T: UniversalWallet,
Instantiate a schema for a single type. This root type will be at index 0
Examples found in repository?
4fn main() {
5 let filter_variants = |name: &str, variant: &str| match name {
6 "Transaction" => variant == "V0",
7 "RuntimeCall" => matches!(variant, "Exchange" | "Bank"),
8 "CallMessage" => matches!(variant, "Keeper" | "TransferWithMemo"),
9 "KeeperAction" => matches!(
10 variant,
11 "UpdateOraclePrices" | "UpdateMarkPrices" | "UpdateOraclePricesWithPythProofs"
12 ),
13 "UniquenessData" => variant == "Generation",
14 _ => panic!("'{name}::{variant}' is unknown"),
15 };
16
17 let our_schema = Schema::of_single_type::<Transaction>().unwrap();
18 let remote: SchemaFile = serde_json::from_str(include_str!("schema.json")).unwrap();
19
20 let left = trim(&our_schema, &filter_variants);
21 let right = trim(&remote.schema, &filter_variants);
22
23 let left = serde_json::to_string_pretty(&left).unwrap();
24 let right = serde_json::to_string_pretty(&right).unwrap();
25 let mut faults = 0usize;
26 for (l, r) in left.lines().zip(right.lines()) {
27 if l != r {
28 faults = faults.saturating_add(1);
29 println!("< {r}");
30 println!("> {l}");
31 if faults >= 10 {
32 break;
33 }
34 } else {
35 println!(" {l}");
36 }
37 }
38 assert_eq!(left, right);
39}Sourcepub fn of_rollup_types_with_chain_data<Transaction, UnsignedTransaction, RuntimeCall, Address>(
chain_data: ChainData,
) -> Result<Schema, SchemaError>where
Transaction: UniversalWallet,
UnsignedTransaction: UniversalWallet,
RuntimeCall: UniversalWallet,
Address: UniversalWallet,
pub fn of_rollup_types_with_chain_data<Transaction, UnsignedTransaction, RuntimeCall, Address>(
chain_data: ChainData,
) -> Result<Schema, SchemaError>where
Transaction: UniversalWallet,
UnsignedTransaction: UniversalWallet,
RuntimeCall: UniversalWallet,
Address: UniversalWallet,
Instantiate a schema for a standard set of rollup types: its complete transaction, its
unsigned transaction, and its call message type.
The types will be accessible using the indices stored in root_type_indices (in the above
order); they can also be queried using the RollupRoots enum through the _rollup-tagged
functions on the schema
Sourcepub fn chain_data(&self) -> &ChainData
pub fn chain_data(&self) -> &ChainData
Get the chain data for the schema.
pub fn metadata_hash(&self) -> Result<[u8; 32], SchemaError>
pub fn from_json(input: &str) -> Result<Schema, Error>
pub fn rollup_expected_index( &self, rollup_type: RollupRoots, ) -> Result<usize, SchemaError>
Sourcepub fn display(
&self,
type_index: usize,
input: &[u8],
) -> Result<String, SchemaError>
pub fn display( &self, type_index: usize, input: &[u8], ) -> Result<String, SchemaError>
Use the schema to display the given type using the provided borsh encoded input
Sourcepub fn json_to_borsh(
&self,
type_index: usize,
input: &str,
) -> Result<Vec<u8>, SchemaError>
pub fn json_to_borsh( &self, type_index: usize, input: &str, ) -> Result<Vec<u8>, SchemaError>
Use the schema to convert a serde-compatible JSON string of the given type into its borsh encoding
Sourcepub fn fill_template_from_json(
&self,
root_index: usize,
template_name: &str,
input: &str,
) -> Result<Vec<u8>, SchemaError>
pub fn fill_template_from_json( &self, root_index: usize, template_name: &str, input: &str, ) -> Result<Vec<u8>, SchemaError>
Use a stub JSON to create a full type using the named template.
Sourcepub fn templates(&self, index: usize) -> Result<Vec<String>, SchemaError>
pub fn templates(&self, index: usize) -> Result<Vec<String>, SchemaError>
Lists all templates available for the given root type.
Sourcepub fn chain_hash(&self) -> Result<[u8; 32], SchemaError>
pub fn chain_hash(&self) -> Result<[u8; 32], SchemaError>
Returns the chain ID calculated using the merkle root of all the schema types, combined with any chain-specific metadata. This allows the chain ID to be used for verification of the schema (and thus verification that a transaction claiming to correspond to a given schema will have the effect it claims).