From 5b9992d6aae3f78447face6bcf9f32a010f43c08 Mon Sep 17 00:00:00 2001 From: 6r1d Date: Tue, 12 Sep 2023 08:30:34 +0300 Subject: [PATCH] [documentation]: #6 Move the Rust examples to this repository Signed-off-by: 6r1d --- Rust/Cargo.toml | 15 +++++ Rust/README.md | 17 +++++ Rust/config.json | 21 ++++++ Rust/examples/client_account_definition.rs | 28 ++++++++ Rust/examples/client_account_registration.rs | 68 ++++++++++++++++++++ Rust/examples/client_domain_registration.rs | 64 ++++++++++++++++++ Rust/examples/client_json_config.rs | 29 +++++++++ Rust/src/main.rs | 3 + 8 files changed, 245 insertions(+) create mode 100644 Rust/Cargo.toml create mode 100644 Rust/README.md create mode 100644 Rust/config.json create mode 100644 Rust/examples/client_account_definition.rs create mode 100644 Rust/examples/client_account_registration.rs create mode 100644 Rust/examples/client_domain_registration.rs create mode 100644 Rust/examples/client_json_config.rs create mode 100644 Rust/src/main.rs diff --git a/Rust/Cargo.toml b/Rust/Cargo.toml new file mode 100644 index 0000000..3f8e1cb --- /dev/null +++ b/Rust/Cargo.toml @@ -0,0 +1,15 @@ +[package] +name = "iroha_2_examples" +version = "0.1.0" +edition = "2021" + +[dependencies] +iroha_data_model = { "git" = "https://github.com/hyperledger/iroha.git", branch = "iroha2-dev" } +iroha_crypto = { "git" = "https://github.com/hyperledger/iroha.git", branch = "iroha2-dev" } +iroha_client = { "git" = "https://github.com/hyperledger/iroha.git", branch = "iroha2-dev" } +iroha_config = { "git" = "https://github.com/hyperledger/iroha.git", branch = "iroha2-dev" } + +eyre = "0.6.8" + +serde = { version = "1.0.151", default-features = false } +serde_json = { version = "1.0.91", default-features = false } diff --git a/Rust/README.md b/Rust/README.md new file mode 100644 index 0000000..f64934d --- /dev/null +++ b/Rust/README.md @@ -0,0 +1,17 @@ +# Rust examples for Iroha 2 + +## Running the examples + +To run the examples, you need to install [`cargo-nextest`](https://nexte.st/) first. + +```bash +cargo install cargo-nextest +``` + +After it is installed, type: + +```bash +cargo nextest run +``` + +You'll Cargo install the packages that are needed for the tests and the test code will run. \ No newline at end of file diff --git a/Rust/config.json b/Rust/config.json new file mode 100644 index 0000000..88dfd17 --- /dev/null +++ b/Rust/config.json @@ -0,0 +1,21 @@ +{ + "PUBLIC_KEY": "ed01207233BFC89DCBD68C19FDE6CE6158225298EC1131B6A130D1AEB454C1AB5183C0", + "PRIVATE_KEY": { + "digest_function": "ed25519", + "payload": "9ac47abf59b356e0bd7dcbbbb4dec080e302156a48ca907e47cb6aea1d32719e7233bfc89dcbd68c19fde6ce6158225298ec1131b6a130d1aeb454c1ab5183c0" + }, + "ACCOUNT_ID": "alice@wonderland", + "BASIC_AUTH": { + "web_login": "mad_hatter", + "password": "ilovetea" + }, + "TORII_API_URL": "http://127.0.0.1:8080/", + "TORII_TELEMETRY_URL": "http://127.0.0.1:8180/", + "TRANSACTION_TIME_TO_LIVE_MS": 100000, + "TRANSACTION_STATUS_TIMEOUT_MS": 15000, + "TRANSACTION_LIMITS": { + "max_instruction_number": 4096, + "max_wasm_size_bytes": 4194304 + }, + "ADD_TRANSACTION_NONCE": false +} diff --git a/Rust/examples/client_account_definition.rs b/Rust/examples/client_account_definition.rs new file mode 100644 index 0000000..55ead08 --- /dev/null +++ b/Rust/examples/client_account_definition.rs @@ -0,0 +1,28 @@ +use eyre::{Error}; + +fn main() { + account_definition_test() + .expect("Account definition example is expected to work correctly"); + + println!("Account definition example works!"); +} + +fn account_definition_test() -> Result<(), Error> { + // #region account_definition_comparison + use iroha_data_model::prelude::AccountId; + + // Create an `iroha_data_model::AccountId` instance + // with a DomainId instance and a Domain ID for an account + let longhand_account_id = AccountId::new("white_rabbit".parse()?, "looking_glass".parse()?); + let account_id: AccountId = "white_rabbit@looking_glass" + .parse() + .expect("Valid, because the string contains no whitespace, has a single '@' character and is not empty after"); + + // Check that two ways to define an account match + assert_eq!(account_id, longhand_account_id); + + // #endregion account_definition_comparison + + // Finish the test successfully + Ok(()) +} diff --git a/Rust/examples/client_account_registration.rs b/Rust/examples/client_account_registration.rs new file mode 100644 index 0000000..5528795 --- /dev/null +++ b/Rust/examples/client_account_registration.rs @@ -0,0 +1,68 @@ +use std::fs::File; +use eyre::{Error, WrapErr}; +use iroha_config::client::Configuration; + +fn main() { + // #region rust_config_load + let config_loc = "../configs/client/config.json"; + let file = File::open(config_loc) + .wrap_err("Unable to load the configuration file at `.....`") + .expect("Config file is loading normally."); + let config: Configuration = serde_json::from_reader(file) + .wrap_err("Failed to parse `../configs/client/config.json`") + .expect("Verified in tests"); + // #endregion rust_config_load + + account_registration_test(&config) + .expect("Domain registration example is expected to work correctly"); + + println!("Domain registration example works!"); +} + +fn account_registration_test(config: &Configuration) -> Result<(), Error> { + // #region register_account_crates + use iroha_client::client::Client; + use iroha_crypto::KeyPair; + use iroha_data_model::{ + metadata::UnlimitedMetadata, + prelude::{Account, AccountId, InstructionBox, RegisterBox}, + }; + // #endregion register_account_crates + + // Create an Iroha client + let iroha_client: Client = Client::new(&config)?; + + // #region register_account_create + // Create an AccountId instance by providing the account and domain name + let account_id: AccountId = "white_rabbit@looking_glass" + .parse() + .expect("Valid, because the string contains no whitespace, has a single '@' character and is not empty after"); + // #endregion register_account_create + + // TODO: consider getting a key from white_rabbit + // Generate a new public key for a new account + let (public_key, _) = KeyPair::generate() + .expect("Failed to generate KeyPair") + .into(); + + // #region register_account_generate + // Generate a new account + let create_account = RegisterBox::new(Account::new(account_id, [public_key])); + // #endregion register_account_generate + + // #region register_account_prepare_tx + // Prepare a transaction using the + // Account's RegisterBox + let metadata = UnlimitedMetadata::new(); + let instructions: Vec = vec![create_account.into()]; + let tx = iroha_client.build_transaction(instructions, metadata)?; + // #endregion register_account_prepare_tx + + // #region register_account_submit_tx + // Submit a prepared account registration transaction + iroha_client.submit_transaction(&tx)?; + // #endregion register_account_submit_tx + + // Finish the test successfully + Ok(()) +} diff --git a/Rust/examples/client_domain_registration.rs b/Rust/examples/client_domain_registration.rs new file mode 100644 index 0000000..544b878 --- /dev/null +++ b/Rust/examples/client_domain_registration.rs @@ -0,0 +1,64 @@ +use std::fs::File; +use eyre::{Error, WrapErr}; +use iroha_config::client::Configuration; + +fn main() { + // #region rust_config_load + let config_loc = "../configs/client/config.json"; + let file = File::open(config_loc) + .wrap_err("Unable to load the configuration file at `.....`") + .expect("Config file is loading normally."); + let config: Configuration = serde_json::from_reader(file) + .wrap_err("Failed to parse `../configs/client/config.json`") + .expect("Verified in tests"); + // #endregion rust_config_load + + domain_registration_test(&config) + .expect("Domain registration example is expected to work correctly"); + + println!("Domain registration example works!"); +} + +fn domain_registration_test(config: &Configuration) -> Result<(), Error> { + // #region domain_register_example_crates + use iroha_client::client::Client; + use iroha_data_model::{ + metadata::UnlimitedMetadata, + prelude::{Domain, DomainId, InstructionBox, RegisterBox}, + }; + // #endregion domain_register_example_crates + + // #region domain_register_example_create_domain + // Create a domain Id + let looking_glass: DomainId = "looking_glass".parse()?; + // #endregion domain_register_example_create_domain + + // #region domain_register_example_create_isi + // Create an ISI + let create_looking_glass = RegisterBox::new(Domain::new(looking_glass)); + // #endregion domain_register_example_create_isi + + // #region rust_client_create + // Create an Iroha client + let iroha_client: Client = Client::new(&config)?; + // #endregion rust_client_create + + // #region domain_register_example_prepare_tx + // Prepare a transaction + let metadata = UnlimitedMetadata::default(); + let instructions: Vec = vec![create_looking_glass.into()]; + let tx = iroha_client + .build_transaction(instructions, metadata) + .wrap_err("Error building a domain registration transaction")?; + // #endregion domain_register_example_prepare_tx + + // #region domain_register_example_submit_tx + // Submit a prepared domain registration transaction + iroha_client + .submit_transaction(&tx) + .wrap_err("Failed to submit transaction")?; + // #endregion domain_register_example_submit_tx + + // Finish the test successfully + Ok(()) +} diff --git a/Rust/examples/client_json_config.rs b/Rust/examples/client_json_config.rs new file mode 100644 index 0000000..3372595 --- /dev/null +++ b/Rust/examples/client_json_config.rs @@ -0,0 +1,29 @@ +use std::fs::File; +use eyre::{Error, WrapErr}; +use iroha_config::client::Configuration; + +fn main() { + // #region rust_config_load + let config_loc = "../configs/client/config.json"; + let file = File::open(config_loc) + .wrap_err("Unable to load the configuration file at `.....`") + .expect("Config file is loading normally."); + let config: Configuration = serde_json::from_reader(file) + .wrap_err("Failed to parse `../configs/client/config.json`") + .expect("Verified in tests"); + // #endregion rust_config_load + + json_config_client_test(&config) + .expect("JSON config client example is expected to work correctly"); + + println!("JSON client configuration test passed successfully!"); +} + +fn json_config_client_test(config: &Configuration) -> Result<(), Error> { + use iroha_client::client::Client; + + // Initialise a client with a provided config + let _current_client: Client = Client::new(&config)?; + + Ok(()) +} diff --git a/Rust/src/main.rs b/Rust/src/main.rs new file mode 100644 index 0000000..e7a11a9 --- /dev/null +++ b/Rust/src/main.rs @@ -0,0 +1,3 @@ +fn main() { + println!("Hello, world!"); +}