[refactor]: Add AssetDefinition builder.

appetrosyan · appetrosyan · commit 6c2f30bf5dc5 · 2022-04-07T10:57:29.000+04:00
Signed-off-by: Aleksandr Petrosyan &lt;a-p-petrosyan@yandex.ru&gt;
diff --git a/cli/src/torii/tests.rs b/cli/src/torii/tests.rs
@@ -258,10 +258,13 @@ fn register_account(name: &str) -> Instruction {
 }
 
 fn register_asset_definition(name: &str) -> Instruction {
-    RegisterBox::new(AssetDefinition::new_quantity(AssetDefinitionId::new(
-        name.parse().expect("Valid"),
-        DOMAIN.parse().expect("Valid"),
-    )))
+    RegisterBox::new(
+        AssetDefinition::quantity(AssetDefinitionId::new(
+            name.parse().expect("Valid"),
+            DOMAIN.parse().expect("Valid"),
+        ))
+        .build(),
+    )
     .into()
 }
 
diff --git a/client/benches/torii.rs b/client/benches/torii.rs
@@ -59,7 +59,8 @@ fn query_requests(criterion: &mut Criterion) {
             .public_key],
     ));
     let asset_definition_id = AssetDefinitionId::new("xor".parse().expect("Valid"), domain_id);
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id.clone()));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(asset_definition_id.clone()).build());
     let quantity: u32 = 200;
     let mint_asset = MintBox::new(
         Value::U32(quantity),
diff --git a/client/examples/million_accounts_genesis.rs b/client/examples/million_accounts_genesis.rs
@@ -25,7 +25,7 @@ fn main() {
                 format!("wonderland-{}", num).parse().expect("Valid"),
             );
             let create_asset =
-                RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id.clone()));
+                RegisterBox::new(AssetDefinition::quantity(asset_definition_id.clone()).build());
             ret.push(GenesisTransaction {
                 isi: small::SmallVec(smallvec::smallvec![create_asset.into()]),
             });
diff --git a/client/tests/integration/add_asset.rs b/client/tests/integration/add_asset.rs
@@ -17,7 +17,8 @@ fn client_add_asset_quantity_to_existing_asset_should_increase_asset_amount() ->
     // Given
     let account_id = AccountId::from_str("alice@wonderland").expect("Valid");
     let asset_definition_id = AssetDefinitionId::from_str("xor#wonderland").expect("Valid");
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id.clone()));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(asset_definition_id.clone()).build());
     let metadata = iroha_data_model::metadata::UnlimitedMetadata::default();
     //When
     let quantity: u32 = 200;
@@ -48,9 +49,8 @@ fn client_add_big_asset_quantity_to_existing_asset_should_increase_asset_amount(
     // Given
     let account_id = AccountId::from_str("alice@wonderland").expect("Valid");
     let asset_definition_id = AssetDefinitionId::from_str("xor#wonderland").expect("Valid");
-    let create_asset = RegisterBox::new(AssetDefinition::new_big_quantity(
-        asset_definition_id.clone(),
-    ));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::big_quantity(asset_definition_id.clone()).build());
     let metadata = iroha_data_model::metadata::UnlimitedMetadata::default();
     //When
     let quantity: u128 = 2_u128.pow(65);
@@ -80,7 +80,7 @@ fn client_add_asset_with_decimal_should_increase_asset_amount() -> Result<()> {
     // Given
     let account_id = AccountId::from_str("alice@wonderland").expect("Valid");
     let asset_definition_id = AssetDefinitionId::from_str("xor#wonderland").expect("Valid");
-    let identifiable_box = AssetDefinition::new_fixed_precision(asset_definition_id.clone());
+    let identifiable_box = AssetDefinition::fixed(asset_definition_id.clone()).build();
     let create_asset = RegisterBox::new(identifiable_box);
     let metadata = iroha_data_model::metadata::UnlimitedMetadata::default();
 
@@ -132,18 +132,16 @@ fn client_add_asset_with_name_length_more_than_limit_should_not_commit_transacti
 
     // Given
     let normal_asset_definition_id = AssetDefinitionId::from_str("xor#wonderland").expect("Valid");
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(
-        normal_asset_definition_id.clone(),
-    ));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(normal_asset_definition_id.clone()).build());
     test_client.submit(create_asset)?;
     iroha_logger::info!("Creating asset");
 
     let too_long_asset_name = "0".repeat(2_usize.pow(14));
     let incorrect_asset_definition_id =
         AssetDefinitionId::from_str(&(too_long_asset_name + "#wonderland")).expect("Valid");
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(
-        incorrect_asset_definition_id.clone(),
-    ));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(incorrect_asset_definition_id.clone()).build());
 
     test_client.submit(create_asset)?;
     iroha_logger::info!("Creating another asset");
diff --git a/client/tests/integration/asset_propagation.rs b/client/tests/integration/asset_propagation.rs
@@ -25,7 +25,8 @@ fn client_add_asset_quantity_to_existing_asset_should_increase_asset_amount_on_a
         [KeyPair::generate()?.public_key],
     ));
     let asset_definition_id = AssetDefinitionId::from_str("xor#domain")?;
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id.clone()));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(asset_definition_id.clone()).build());
     iroha_client.submit_all(vec![
         create_domain.into(),
         create_account.into(),
diff --git a/client/tests/integration/multiple_blocks_created.rs b/client/tests/integration/multiple_blocks_created.rs
@@ -28,7 +28,8 @@ fn long_multiple_blocks_created() {
             .public_key],
     ));
     let asset_definition_id: AssetDefinitionId = "xor#domain".parse().expect("Valid");
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id.clone()));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(asset_definition_id.clone()).build());
 
     iroha_client
         .submit_all(vec![
diff --git a/client/tests/integration/multisignature_account.rs b/client/tests/integration/multisignature_account.rs
@@ -19,7 +19,8 @@ fn transaction_signed_by_new_signatory_of_account_should_pass() -> Result<()> {
     // Given
     let account_id: AccountId = "alice@wonderland".parse().expect("Valid");
     let asset_definition_id: AssetDefinitionId = "xor#wonderland".parse().expect("Valid");
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id.clone()));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(asset_definition_id.clone()).build());
     let key_pair = KeyPair::generate()?;
     let add_signatory = MintBox::new(
         key_pair.public_key.clone(),
diff --git a/client/tests/integration/multisignature_transaction.rs b/client/tests/integration/multisignature_transaction.rs
@@ -28,7 +28,8 @@ fn multisignature_transactions_should_wait_for_all_signatures() {
         [key_pair_1.public_key.clone()],
     ));
     let asset_definition_id = AssetDefinitionId::from_str("xor#domain").expect("Valid");
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id.clone()));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(asset_definition_id.clone()).build());
     let set_signature_condition = MintBox::new(
         SignatureCheckCondition(
             ContainsAll::new(
diff --git a/client/tests/integration/non_mintable.rs b/client/tests/integration/non_mintable.rs
@@ -15,9 +15,11 @@ fn non_mintable_asset_can_be_minted_once_but_not_twice() -> Result<()> {
     // Given
     let account_id = AccountId::from_str("alice@wonderland").expect("Valid");
     let asset_definition_id = AssetDefinitionId::from_str("xor#wonderland").expect("Valid");
-    let create_asset = RegisterBox::new(IdentifiableBox::from(
-        AssetDefinition::new_quantity_token(asset_definition_id.clone()),
-    ));
+    let create_asset = RegisterBox::new(
+        AssetDefinition::quantity(asset_definition_id.clone())
+            .mintable_once()
+            .build(),
+    );
 
     let metadata = UnlimitedMetadata::default();
 
@@ -29,7 +31,7 @@ fn non_mintable_asset_can_be_minted_once_but_not_twice() -> Result<()> {
         )),
     );
 
-    let instructions: Vec<Instruction> = vec![create_asset.into(), mint.clone().into()];
+    let instructions: [Instruction; 2] = [create_asset.into(), mint.clone().into()];
     let tx = test_client.build_transaction(instructions.into(), metadata)?;
 
     // We can register and mint the non-mintable token
@@ -42,7 +44,7 @@ fn non_mintable_asset_can_be_minted_once_but_not_twice() -> Result<()> {
     })?;
 
     // We can submit the request to mint again.
-    test_client.submit_all(vec![mint.into()])?;
+    test_client.submit_all([mint.into()])?;
 
     // However, this will fail
     assert!(test_client
diff --git a/client/tests/integration/pagination.rs b/client/tests/integration/pagination.rs
@@ -17,9 +17,11 @@ fn client_add_asset_quantity_to_existing_asset_should_increase_asset_amount() {
     let register: Vec<Instruction> = ('a'..'z')
         .map(|c| c.to_string())
         .map(|name| (name + "#wonderland").parse().expect("Valid"))
-        .map(AssetDefinition::new_quantity)
-        .map(RegisterBox::new)
-        .map(Instruction::Register)
+        .map(|asset_definition_id| {
+            Instruction::Register(RegisterBox::new(
+                AssetDefinition::quantity(asset_definition_id).build(),
+            ))
+        })
         .collect();
     iroha_client
         .submit_all(register)
diff --git a/client/tests/integration/permissions.rs b/client/tests/integration/permissions.rs
@@ -41,7 +41,8 @@ fn permissions_disallow_asset_transfer() {
     let alice_id = AccountId::from_str("alice@wonderland").expect("Valid");
     let bob_id = AccountId::from_str("bob@wonderland").expect("Valid");
     let asset_definition_id: AssetDefinitionId = "xor#wonderland".parse().expect("Valid");
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id.clone()));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(asset_definition_id.clone()).build());
     let register_bob = RegisterBox::new(Account::new(bob_id.clone(), []));
 
     let alice_start_assets = get_assets(&mut iroha_client, &alice_id);
@@ -100,7 +101,8 @@ fn permissions_disallow_asset_burn() {
     let alice_id = "alice@wonderland".parse().expect("Valid");
     let bob_id: AccountId = "bob@wonderland".parse().expect("Valid");
     let asset_definition_id = AssetDefinitionId::from_str("xor#wonderland").expect("Valid");
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id.clone()));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(asset_definition_id.clone()).build());
     let register_bob = RegisterBox::new(Account::new(bob_id.clone(), []));
 
     let alice_start_assets = get_assets(&mut iroha_client, &alice_id);
diff --git a/client/tests/integration/restart_peer.rs b/client/tests/integration/restart_peer.rs
@@ -30,7 +30,8 @@ fn restarted_peer_should_have_the_same_asset_amount() -> Result<()> {
 
     let account_id = AccountId::from_str("alice@wonderland").unwrap();
     let asset_definition_id = AssetDefinitionId::from_str("xor#wonderland").unwrap();
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id.clone()));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(asset_definition_id.clone()).build());
     iroha_client.submit(create_asset)?;
     thread::sleep(pipeline_time * 2);
     //When
diff --git a/client/tests/integration/roles.rs b/client/tests/integration/roles.rs
@@ -12,17 +12,14 @@ fn register_empty_role() -> Result<()> {
     wait_for_genesis_committed(&vec![test_client.clone()], 0);
 
     let role_id = iroha_data_model::role::Id::new("root".parse::<Name>().expect("Valid"));
-    let register_role = RegisterBox::new(IdentifiableBox::from(Role::new(
-        role_id,
-        Permissions::new(),
-    )));
+    let register_role = RegisterBox::new(Role::new(role_id, Permissions::new()));
 
     test_client.submit(register_role)?;
     Ok(())
 }
 
 #[test]
-fn register_role_with_empty_token() -> Result<()> {
+fn register_role_with_empty_token_params() -> Result<()> {
     let (_rt, _peer, mut test_client) = <TestPeer>::start_test_with_runtime();
     wait_for_genesis_committed(&vec![test_client.clone()], 0);
 
@@ -32,7 +29,7 @@ fn register_role_with_empty_token() -> Result<()> {
         name: "token".parse().expect("Valid"),
         params: BTreeMap::new(),
     });
-    let register_role = RegisterBox::new(IdentifiableBox::from(Role::new(role_id, permissions)));
+    let register_role = RegisterBox::new(Role::new(role_id, permissions));
 
     test_client.submit(register_role)?;
     Ok(())
diff --git a/client/tests/integration/transfer_asset.rs b/client/tests/integration/transfer_asset.rs
@@ -32,7 +32,8 @@ fn client_can_transfer_asset_to_another_account() {
     ));
     let asset_definition_id: AssetDefinitionId = "xor#domain".parse().expect("Valid");
     let quantity: u32 = 200;
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id.clone()));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(asset_definition_id.clone()).build());
     let mint_asset = MintBox::new(
         Value::U32(quantity),
         IdBox::AssetId(AssetId::new(
diff --git a/client/tests/integration/triggers/event_trigger.rs b/client/tests/integration/triggers/event_trigger.rs
@@ -36,7 +36,7 @@ fn test_mint_asset_when_new_asset_definition_created() -> Result<()> {
 
     let tea_definition_id = "tea#wonderland".parse()?;
     let register_tea_definition =
-        RegisterBox::new(AssetDefinition::new_quantity(tea_definition_id));
+        RegisterBox::new(AssetDefinition::quantity(tea_definition_id).build());
     test_client.submit_blocking(register_tea_definition)?;
 
     let new_value = get_asset_value(&mut test_client, asset_id)?;
diff --git a/client/tests/integration/tx_history.rs b/client/tests/integration/tx_history.rs
@@ -18,7 +18,8 @@ fn client_has_rejected_and_acepted_txs_should_return_tx_history() {
     // Given
     let account_id = AccountId::from_str("alice@wonderland").expect("Valid");
     let asset_definition_id = AssetDefinitionId::from_str("xor#wonderland").expect("Valid");
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id.clone()));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(asset_definition_id.clone()).build());
     iroha_client
         .submit(create_asset)
         .expect("Failed to prepare state.");
diff --git a/client/tests/integration/tx_rollback.rs b/client/tests/integration/tx_rollback.rs
@@ -19,7 +19,7 @@ fn client_sends_transaction_with_invalid_instruction_should_not_see_any_changes(
     let account_id = AccountId::from_str("alice@wonderland").expect("Valid");
     let asset_definition_id = AssetDefinitionId::from_str("xor#wonderland").expect("Valid");
     let wrong_asset_definition_id = AssetDefinitionId::from_str("ksor#wonderland").expect("Valid");
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id));
+    let create_asset = RegisterBox::new(AssetDefinition::quantity(asset_definition_id).build());
     let quantity: u32 = 200;
     let mint_asset = MintBox::new(
         Value::U32(quantity),
diff --git a/client/tests/integration/unregister_peer.rs b/client/tests/integration/unregister_peer.rs
@@ -107,7 +107,8 @@ fn init() -> Result<(
         [KeyPair::generate()?.public_key],
     ));
     let asset_definition_id: AssetDefinitionId = "xor#domain".parse().expect("Valid");
-    let create_asset = RegisterBox::new(AssetDefinition::new_quantity(asset_definition_id.clone()));
+    let create_asset =
+        RegisterBox::new(AssetDefinition::quantity(asset_definition_id.clone()).build());
     client.submit_all(vec![
         create_domain.into(),
         create_account.into(),
diff --git a/client_cli/src/main.rs b/client_cli/src/main.rs
@@ -466,7 +466,7 @@ mod asset {
                 metadata: Metadata(metadata),
             } = self;
             submit(
-                RegisterBox::new(AssetDefinition::new(id, value_type, !unmintable)),
+                RegisterBox::new(AssetDefinition::from((id, value_type, !unmintable))),
                 cfg,
                 metadata,
             )
diff --git a/core/benches/validation.rs b/core/benches/validation.rs
@@ -39,11 +39,7 @@ fn build_test_transaction(keys: KeyPair) -> Transaction {
         "xor".parse().expect("Valid"),
         domain_name.parse().expect("Valid"),
     );
-    let create_asset = RegisterBox::new(AssetDefinition::new(
-        asset_definition_id,
-        AssetValueType::Quantity,
-        true,
-    ));
+    let create_asset = RegisterBox::new(AssetDefinition::quantity(asset_definition_id).build());
     let instructions: Vec<Instruction> = vec![
         create_domain.into(),
         create_account.into(),
diff --git a/core/src/smartcontracts/isi/asset.rs b/core/src/smartcontracts/isi/asset.rs
@@ -11,7 +11,7 @@ use super::prelude::*;
 /// - update metadata
 /// - transfer, etc.
 pub mod isi {
-    use iroha_data_model::asset::Mintable;
+    use iroha_data_model::{asset::Mintable, MintabilityError};
     use iroha_logger::prelude::*;
 
     use super::*;
@@ -44,10 +44,10 @@ pub mod isi {
         let definition = assert_asset_type(definition_id, wsv, expected_value_type)?;
         match definition.mintable() {
             Mintable::Infinitely => Ok(()),
-            Mintable::Not => Err(Error::Mintability(MintabilityError::MintUnmintableError)),
+            Mintable::Not => Err(Error::Mintability(MintabilityError::MintUnmintable)),
             Mintable::Once => {
                 wsv.modify_asset_definition_entry(definition_id, |entry| {
-                    entry.forbid_minting();
+                    entry.forbid_minting()?;
                     Ok(AssetDefinitionEvent::MintabilityChanged(
                         definition_id.clone(),
                     ))
diff --git a/core/src/smartcontracts/isi/mod.rs b/core/src/smartcontracts/isi/mod.rs
@@ -35,7 +35,9 @@ pub mod error {
     };
 
     use iroha_crypto::HashOf;
-    use iroha_data_model::{fixed::FixedPointOperationError, metadata, prelude::*};
+    use iroha_data_model::{
+        fixed::FixedPointOperationError, metadata, prelude::*, MintabilityError,
+    };
     use iroha_schema::IntoSchema;
     use parity_scale_codec::{Decode, Encode};
     use thiserror::Error;
@@ -53,7 +55,7 @@ pub mod error {
         Type(#[source] TypeError),
         /// Failed to assert mintability
         #[error("Mintability violation. {0}")]
-        Mintability(#[source] MintabilityError),
+        Mintability(#[from] MintabilityError),
         /// Failed due to math exception
         #[error("Math error. {0}")]
         Math(#[source] MathError),
@@ -171,14 +173,6 @@ pub mod error {
         Role(RoleId),
     }
 
-    /// Mintability logic error
-    #[derive(Debug, Clone, Error, Copy, PartialEq, Eq)]
-    pub enum MintabilityError {
-        /// Tried to mint an Un-mintable asset.
-        #[error("Minting of this asset is forbidden")]
-        MintUnmintableError,
-    }
-
     /// Type assertion error
     #[derive(Debug, Clone, Error, Copy, PartialEq, Eq)]
     pub enum TypeError {
@@ -646,7 +640,10 @@ mod tests {
         assert!(domain.add_account(account).is_none());
         let asset_definition_id = AssetDefinitionId::from_str("rose#wonderland")?;
         assert!(domain
-            .add_asset_definition(AssetDefinition::new_store(asset_definition_id), account_id)
+            .add_asset_definition(
+                AssetDefinition::store(asset_definition_id).build(),
+                account_id
+            )
             .is_none());
         Ok(World::with([domain], PeersIds::new()))
     }
diff --git a/core/src/smartcontracts/isi/query.rs b/core/src/smartcontracts/isi/query.rs
diff --git a/core/test_network/src/lib.rs b/core/test_network/src/lib.rs
diff --git a/data_model/src/asset.rs b/data_model/src/asset.rs
diff --git a/data_model/src/events/data/events.rs b/data_model/src/events/data/events.rs
diff --git a/data_model/src/events/data/filters.rs b/data_model/src/events/data/filters.rs
diff --git a/data_model/src/lib.rs b/data_model/src/lib.rs
diff --git a/data_model/tests/data_model.rs b/data_model/tests/data_model.rs
diff --git a/permissions_validators/src/public_blockchain/mod.rs b/permissions_validators/src/public_blockchain/mod.rs
