From 208ddc3189e24c1fde87dc2cd0f25c7addbdd4eb Mon Sep 17 00:00:00 2001 From: ghzlatarev Date: Tue, 26 Apr 2022 22:37:32 +0300 Subject: [PATCH 1/4] Initial tests Signed-off-by: ghzlatarev --- Cargo.lock | 1 + runtime/calamari/src/lib.rs | 5 +- runtime/calamari/tests/common/mock.rs | 13 +- runtime/calamari/tests/integration_tests.rs | 525 +++++++++++++++++++- 4 files changed, 535 insertions(+), 9 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index c7dbdcca3..02c8f2a9c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4931,6 +4931,7 @@ dependencies = [ "frame-system", "log", "manta-accounting", + "pallet-balances", "parity-scale-codec", "scale-info", "smallvec", diff --git a/runtime/calamari/src/lib.rs b/runtime/calamari/src/lib.rs index 4e1b80ffc..e16b12a6e 100644 --- a/runtime/calamari/src/lib.rs +++ b/runtime/calamari/src/lib.rs @@ -684,6 +684,9 @@ parameter_types! { pub const AssetManagerPalletId: PalletId = ASSET_MANAGER_PALLET_ID; } +pub type CalamariConcreteFungibleLedger = + ConcreteFungibleLedger; + #[derive(Clone, Eq, PartialEq)] pub struct CalamariAssetConfig; @@ -697,7 +700,7 @@ impl AssetConfig for CalamariAssetConfig { type StorageMetadata = AssetStorageMetadata; type AssetLocation = AssetLocation; type AssetRegistrar = CalamariAssetRegistrar; - type FungibleLedger = ConcreteFungibleLedger; + type FungibleLedger = CalamariConcreteFungibleLedger; } impl pallet_asset_manager::Config for Runtime { diff --git a/runtime/calamari/tests/common/mock.rs b/runtime/calamari/tests/common/mock.rs index b43dae45c..70d5e6fde 100644 --- a/runtime/calamari/tests/common/mock.rs +++ b/runtime/calamari/tests/common/mock.rs @@ -17,11 +17,12 @@ use crate::common::*; pub use calamari_runtime::{ - currency::KMA, Call, CollatorSelection, Democracy, Runtime, Scheduler, Session, System, - TransactionPayment, + currency::KMA, CalamariAssetConfig, Call, CollatorSelection, Democracy, Runtime, Scheduler, + Session, System, TransactionPayment, }; use frame_support::traits::{GenesisBuild, OnFinalize, OnInitialize}; use manta_primitives::{ + assets::AssetConfig, helpers::{get_account_id_from_seed, get_collator_keys_from_seed}, types::{AccountId, AuraId, Balance}, }; @@ -33,6 +34,7 @@ pub struct ExtBuilder { desired_candidates: u32, safe_xcm_version: Option, } +use sp_std::marker::PhantomData; impl Default for ExtBuilder { fn default() -> ExtBuilder { @@ -113,6 +115,13 @@ impl ExtBuilder { .assimilate_storage(&mut t) .unwrap(); + pallet_asset_manager::GenesisConfig:: { + start_id: >::StartNonNativeAssetId::get(), + _marker: PhantomData::::default(), + } + .assimilate_storage(&mut t) + .unwrap(); + >::assimilate_storage( &pallet_xcm::GenesisConfig { safe_xcm_version: self.safe_xcm_version, diff --git a/runtime/calamari/tests/integration_tests.rs b/runtime/calamari/tests/integration_tests.rs index 4da179a87..2b8903cc5 100644 --- a/runtime/calamari/tests/integration_tests.rs +++ b/runtime/calamari/tests/integration_tests.rs @@ -25,9 +25,10 @@ pub use calamari_runtime::{ FEES_PERCENTAGE_TO_AUTHOR, FEES_PERCENTAGE_TO_TREASURY, TIPS_PERCENTAGE_TO_AUTHOR, TIPS_PERCENTAGE_TO_TREASURY, }, - Authorship, Balances, CalamariVesting, Council, Democracy, EnactmentPeriod, LaunchPeriod, - NativeTokenExistentialDeposit, Origin, Period, PolkadotXcm, Runtime, Sudo, TechnicalCommittee, - Timestamp, Treasury, Utility, VotingPeriod, + AssetManager, Assets, Authorship, Balances, CalamariAssetConfig, + CalamariConcreteFungibleLedger, CalamariVesting, Council, Democracy, EnactmentPeriod, + LaunchPeriod, NativeTokenExistentialDeposit, Origin, Period, PolkadotXcm, Runtime, Sudo, + TechnicalCommittee, Timestamp, Treasury, Utility, VotingPeriod, XcmFeesAccount, }; use frame_support::{ @@ -38,12 +39,23 @@ use frame_support::{ weights::constants::*, StorageHasher, Twox128, }; - use manta_primitives::{ + assets::{ + AssetConfig, AssetLocation, AssetRegistrarMetadata, ConcreteFungibleLedger, FungibleLedger, + FungibleLedgerError, + }, constants::time::{DAYS, HOURS}, helpers::{get_account_id_from_seed, get_collator_keys_from_seed}, types::{AccountId, Header}, }; +use xcm::{ + opaque::latest::{ + Junction::{PalletInstance, Parachain}, + Junctions::X2, + MultiLocation, + }, + VersionedMultiLocation, +}; use pallet_transaction_payment::ChargeTransactionPayment; @@ -366,7 +378,7 @@ fn balances_operations_should_work() { assert_eq!(Balances::free_balance(alice.clone()), INITIAL_BALANCE); assert_eq!(Balances::free_balance(charlie.clone()), INITIAL_BALANCE); - // Should not be able to trnasfer all with this call + // Should not be able to transfer all with this call assert_err!( Balances::transfer_keep_alive( Origin::signed(alice.clone()), @@ -740,7 +752,7 @@ fn batched_registration_of_collator_candidates_works() { #[test] fn sanity_check_weight_per_time_constants_are_as_expected() { // These values comes from Substrate, we want to make sure that if it - // ever changes we don't accidently break Polkadot + // ever changes we don't accidentally break Polkadot assert_eq!(WEIGHT_PER_SECOND, 1_000_000_000_000); assert_eq!(WEIGHT_PER_MILLIS, WEIGHT_PER_SECOND / 1000); assert_eq!(WEIGHT_PER_MICROS, WEIGHT_PER_MILLIS / 1000); @@ -948,3 +960,504 @@ fn verify_pallet_indices() { is_pallet_index::(42); is_pallet_index::(50); } + +#[test] +fn concrete_fungible_ledger_transfers_work() { + let alice = get_account_id_from_seed::("Alice"); + let bob = get_account_id_from_seed::("Bob"); + let charlie = get_account_id_from_seed::("Charlie"); + + ExtBuilder::default() + .with_balances(vec![ + (alice.clone(), INITIAL_BALANCE), + (bob.clone(), INITIAL_BALANCE), + (charlie.clone(), INITIAL_BALANCE), + ]) + .build() + .execute_with(|| { + let transfer_amount = 10 * KMA; + let mut current_balance_alice = INITIAL_BALANCE; + let mut current_balance_charlie = INITIAL_BALANCE; + + // Switch transfer amount + assert_err!( + CalamariConcreteFungibleLedger::transfer( + >::NativeAssetId::get(), + &alice.clone(), + &charlie.clone(), + INITIAL_BALANCE + 1, + ), + // Not enough funds + FungibleLedgerError::InvalidTransfer + ); + assert_eq!(Balances::free_balance(alice.clone()), current_balance_alice); + assert_eq!( + Balances::free_balance(charlie.clone()), + current_balance_charlie + ); + + assert_err!( + CalamariConcreteFungibleLedger::transfer( + >::NativeAssetId::get(), + &alice.clone(), + &charlie.clone(), + INITIAL_BALANCE, + ), + // Because keep_alive is set to true + FungibleLedgerError::InvalidTransfer + ); + assert_eq!(Balances::free_balance(alice.clone()), current_balance_alice); + assert_eq!( + Balances::free_balance(charlie.clone()), + current_balance_charlie + ); + + assert_ok!(ConcreteFungibleLedger::< + Runtime, + CalamariAssetConfig, + Balances, + Assets, + >::transfer( + >::NativeAssetId::get(), + &alice.clone(), + &charlie.clone(), + transfer_amount, + )); + current_balance_alice -= transfer_amount; + current_balance_charlie += transfer_amount; + assert_eq!(Balances::free_balance(alice.clone()), current_balance_alice); + assert_eq!( + Balances::free_balance(charlie.clone()), + current_balance_charlie + ); + + let new_account = get_account_id_from_seed::("NewAccount"); + assert_err!( + CalamariConcreteFungibleLedger::transfer( + >::NativeAssetId::get(), + &alice.clone(), + &new_account.clone(), + NativeTokenExistentialDeposit::get() - 1, + ), + // Because the new balance will be below ED + FungibleLedgerError::InvalidTransfer + ); + assert_ok!(ConcreteFungibleLedger::< + Runtime, + CalamariAssetConfig, + Balances, + Assets, + >::transfer( + >::NativeAssetId::get(), + &alice.clone(), + &new_account.clone(), + NativeTokenExistentialDeposit::get(), + )); + current_balance_alice -= NativeTokenExistentialDeposit::get(); + assert_eq!(Balances::free_balance(alice.clone()), current_balance_alice); + assert_eq!( + Balances::free_balance(new_account.clone()), + NativeTokenExistentialDeposit::get() + ); + + assert_ok!(ConcreteFungibleLedger::< + Runtime, + CalamariAssetConfig, + Balances, + Assets, + >::transfer( + >::NativeAssetId::get(), + &bob.clone(), + &alice.clone(), + // Transfer a large amount + INITIAL_BALANCE - NativeTokenExistentialDeposit::get(), + )); + current_balance_alice += INITIAL_BALANCE - NativeTokenExistentialDeposit::get(); + assert_eq!(Balances::free_balance(alice.clone()), current_balance_alice); + assert_eq!( + Balances::free_balance(bob.clone()), + NativeTokenExistentialDeposit::get() + ); + + let min_balance = 10u128; + // non-native asset id + let asset_metadata = AssetRegistrarMetadata { + name: b"Kusama".to_vec(), + symbol: b"KSM".to_vec(), + decimals: 12, + min_balance: min_balance, + evm_address: None, + is_frozen: false, + is_sufficient: true, + }; + let source_location = + AssetLocation(VersionedMultiLocation::V1(MultiLocation::parent())); + assert_ok!(AssetManager::register_asset( + root_origin(), + source_location.clone(), + asset_metadata.clone() + ),); + // TODO: change u128::MAX when we start using https://github.com/paritytech/substrate/pull/11241 + let amount = INITIAL_BALANCE; + assert_ok!(ConcreteFungibleLedger::< + Runtime, + CalamariAssetConfig, + Balances, + Assets, + >::mint( + >::StartNonNativeAssetId::get(), + &alice.clone(), + amount, + ),); + assert_eq!( + Assets::balance( + >::StartNonNativeAssetId::get(), + alice.clone() + ), + amount + ); + + assert_err!( + CalamariConcreteFungibleLedger::transfer( + >::StartNonNativeAssetId::get(), + &alice.clone(), + &bob.clone(), + // Fail because of ED + amount, + ), + FungibleLedgerError::InvalidTransfer + ); + assert_eq!( + Assets::balance( + >::StartNonNativeAssetId::get(), + alice.clone() + ), + amount + ); + + assert_err!( + CalamariConcreteFungibleLedger::transfer( + >::StartNonNativeAssetId::get(), + &alice.clone(), + &bob.clone(), + // Fail because of ED + min_balance - 1, + ), + FungibleLedgerError::InvalidTransfer + ); + assert_eq!( + Assets::balance( + >::StartNonNativeAssetId::get(), + alice.clone() + ), + amount + ); + + assert_ok!(ConcreteFungibleLedger::< + Runtime, + CalamariAssetConfig, + Balances, + Assets, + >::transfer( + >::StartNonNativeAssetId::get(), + &alice.clone(), + &bob.clone(), + transfer_amount, + ),); + assert_eq!( + Assets::balance( + >::StartNonNativeAssetId::get(), + alice.clone() + ), + INITIAL_BALANCE - transfer_amount + ); + assert_eq!( + Assets::balance( + >::StartNonNativeAssetId::get(), + bob.clone() + ), + transfer_amount + ); + + // Switch asset-id + assert_err!( + CalamariConcreteFungibleLedger::transfer( + >::DummyAssetId::get(), + &alice.clone(), + &charlie.clone(), + transfer_amount, + ), + FungibleLedgerError::InvalidAssetId + ); + assert_eq!(Balances::free_balance(alice.clone()), current_balance_alice); + assert_eq!( + Balances::free_balance(charlie.clone()), + current_balance_charlie + ); + + assert_err!( + CalamariConcreteFungibleLedger::transfer( + u32::MAX, + &alice.clone(), + &charlie.clone(), + transfer_amount, + ), + FungibleLedgerError::InvalidTransfer + ); + }); +} + +#[test] +fn concrete_fungible_ledger_can_deposit_and_mint_works() { + let alice = get_account_id_from_seed::("Alice"); + + ExtBuilder::default() + .with_balances(vec![(alice.clone(), INITIAL_BALANCE)]) + .build() + .execute_with(|| { + let new_account = get_account_id_from_seed::("NewAccount"); + assert_err!( + CalamariConcreteFungibleLedger::can_deposit( + >::NativeAssetId::get(), + &new_account.clone(), + NativeTokenExistentialDeposit::get() - 1, + ), + FungibleLedgerError::BelowMinimum + ); + + let remaining_to_max = u128::MAX - Balances::total_issuance(); + assert_ok!(ConcreteFungibleLedger::< + Runtime, + CalamariAssetConfig, + Balances, + Assets, + >::mint( + >::NativeAssetId::get(), + &new_account.clone(), + remaining_to_max, + ),); + assert_eq!( + Balances::free_balance(new_account.clone()), + remaining_to_max + ); + assert_err!( + CalamariConcreteFungibleLedger::can_deposit( + >::NativeAssetId::get(), + &new_account.clone(), + 1, + ), + FungibleLedgerError::Overflow + ); + + let min_balance = 10u128; + // non-native asset id + let asset_metadata = AssetRegistrarMetadata { + name: b"Kusama".to_vec(), + symbol: b"KSM".to_vec(), + decimals: 12, + min_balance: min_balance, + evm_address: None, + is_frozen: false, + is_sufficient: true, + }; + let source_location = + AssetLocation(VersionedMultiLocation::V1(MultiLocation::parent())); + assert_ok!(AssetManager::register_asset( + root_origin(), + source_location.clone(), + asset_metadata.clone() + ),); + + assert_err!( + CalamariConcreteFungibleLedger::can_deposit( + >::StartNonNativeAssetId::get(), + &alice.clone(), + 0, + ), + FungibleLedgerError::BelowMinimum + ); + assert_err!( + CalamariConcreteFungibleLedger::can_deposit( + >::StartNonNativeAssetId::get() + 1, + &alice.clone(), + 11, + ), + FungibleLedgerError::UnknownAsset + ); + assert_ok!(ConcreteFungibleLedger::< + Runtime, + CalamariAssetConfig, + Balances, + Assets, + >::mint( + >::StartNonNativeAssetId::get(), + &alice.clone(), + u128::MAX, + ),); + assert_eq!( + Assets::balance( + >::StartNonNativeAssetId::get(), + alice.clone() + ), + u128::MAX + ); + assert_err!( + CalamariConcreteFungibleLedger::can_deposit( + >::StartNonNativeAssetId::get(), + &alice.clone(), + 1, + ), + FungibleLedgerError::Overflow + ); + + let asset_metadata = AssetRegistrarMetadata { + name: b"Rococo".to_vec(), + symbol: b"Roc".to_vec(), + decimals: 12, + min_balance: min_balance, + evm_address: None, + is_frozen: false, + is_sufficient: false, + }; + + let source_location = AssetLocation(VersionedMultiLocation::V1(MultiLocation::new( + 1, + X2(Parachain(1), PalletInstance(1)), + ))); + assert_ok!(AssetManager::register_asset( + root_origin(), + source_location.clone(), + asset_metadata.clone() + ),); + assert_err!( + CalamariConcreteFungibleLedger::can_deposit( + >::StartNonNativeAssetId::get() + 1, + &XcmFeesAccount::get(), + 11, + ), + FungibleLedgerError::CannotCreate + ); + }); +} + +#[test] +fn concrete_fungible_ledger_can_withdraw_works() { + let alice = get_account_id_from_seed::("Alice"); + let bob = get_account_id_from_seed::("Bob"); + + ExtBuilder::default() + .with_balances(vec![(alice.clone(), INITIAL_BALANCE)]) + .build() + .execute_with(|| { + assert_err!( + CalamariConcreteFungibleLedger::can_withdraw( + >::NativeAssetId::get(), + &alice.clone(), + INITIAL_BALANCE + 1, + ), + FungibleLedgerError::Underflow + ); + + assert_err!( + CalamariConcreteFungibleLedger::can_withdraw( + >::NativeAssetId::get(), + &alice.clone(), + INITIAL_BALANCE, + ), + FungibleLedgerError::WouldDie + ); + + assert_err!( + CalamariConcreteFungibleLedger::can_withdraw( + >::NativeAssetId::get(), + &bob.clone(), + INITIAL_BALANCE, + ), + FungibleLedgerError::NoFunds + ); + + // Underflow -> NoFunds -> ReducedToZero -> WouldDie -> Frozen + let min_balance = 10u128; + let asset_metadata = AssetRegistrarMetadata { + name: b"Kusama".to_vec(), + symbol: b"KSM".to_vec(), + decimals: 12, + min_balance: min_balance, + evm_address: None, + is_frozen: false, + is_sufficient: true, + }; + let source_location = + AssetLocation(VersionedMultiLocation::V1(MultiLocation::parent())); + assert_ok!(AssetManager::register_asset( + root_origin(), + source_location.clone(), + asset_metadata.clone() + ),); + + assert_ok!(ConcreteFungibleLedger::< + Runtime, + CalamariAssetConfig, + Balances, + Assets, + >::mint( + >::StartNonNativeAssetId::get(), + &alice.clone(), + INITIAL_BALANCE, + ),); + assert_eq!( + Assets::balance( + >::StartNonNativeAssetId::get(), + alice.clone() + ), + INITIAL_BALANCE + ); + + assert_err!( + CalamariConcreteFungibleLedger::can_withdraw( + >::StartNonNativeAssetId::get(), + &alice.clone(), + INITIAL_BALANCE + 1, + ), + FungibleLedgerError::Underflow + ); + + assert_err!( + CalamariConcreteFungibleLedger::can_withdraw( + >::StartNonNativeAssetId::get(), + &alice.clone(), + INITIAL_BALANCE, + ), + FungibleLedgerError::ReducedToZero(0) + ); + + assert_ok!(CalamariConcreteFungibleLedger::can_withdraw( + >::StartNonNativeAssetId::get(), + &alice.clone(), + INITIAL_BALANCE - min_balance, + ),); + + assert_err!( + CalamariConcreteFungibleLedger::can_withdraw( + >::StartNonNativeAssetId::get(), + &bob.clone(), + 10, + ), + FungibleLedgerError::NoFunds + ); + + assert_ok!(Assets::freeze( + Origin::signed(AssetManager::account_id()), + >::StartNonNativeAssetId::get(), + sp_runtime::MultiAddress::Id(alice.clone()), + )); + assert_err!( + CalamariConcreteFungibleLedger::can_withdraw( + >::StartNonNativeAssetId::get(), + &alice.clone(), + 10, + ), + FungibleLedgerError::Frozen + ); + }); +} From a1dd3fe12c479945bcc4b50bb571510c0ed7b3da Mon Sep 17 00:00:00 2001 From: ghzlatarev Date: Wed, 27 Apr 2022 10:36:16 +0300 Subject: [PATCH 2/4] Add comments Signed-off-by: ghzlatarev --- Cargo.lock | 1 - runtime/calamari/tests/integration_tests.rs | 25 ++++++++++++++++----- 2 files changed, 19 insertions(+), 7 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 02c8f2a9c..c7dbdcca3 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -4931,7 +4931,6 @@ dependencies = [ "frame-system", "log", "manta-accounting", - "pallet-balances", "parity-scale-codec", "scale-info", "smallvec", diff --git a/runtime/calamari/tests/integration_tests.rs b/runtime/calamari/tests/integration_tests.rs index 2b8903cc5..44629c572 100644 --- a/runtime/calamari/tests/integration_tests.rs +++ b/runtime/calamari/tests/integration_tests.rs @@ -979,7 +979,9 @@ fn concrete_fungible_ledger_transfers_work() { let mut current_balance_alice = INITIAL_BALANCE; let mut current_balance_charlie = INITIAL_BALANCE; - // Switch transfer amount + // Transfer tests for native assets: + + // Try to transfer more than available assert_err!( CalamariConcreteFungibleLedger::transfer( >::NativeAssetId::get(), @@ -996,6 +998,7 @@ fn concrete_fungible_ledger_transfers_work() { current_balance_charlie ); + // Try to transfer and go below existential deposit assert_err!( CalamariConcreteFungibleLedger::transfer( >::NativeAssetId::get(), @@ -1012,6 +1015,7 @@ fn concrete_fungible_ledger_transfers_work() { current_balance_charlie ); + // A normal transfer should work assert_ok!(ConcreteFungibleLedger::< Runtime, CalamariAssetConfig, @@ -1031,6 +1035,7 @@ fn concrete_fungible_ledger_transfers_work() { current_balance_charlie ); + // Should not be able to create new account with lower than ED balance let new_account = get_account_id_from_seed::("NewAccount"); assert_err!( CalamariConcreteFungibleLedger::transfer( @@ -1042,6 +1047,8 @@ fn concrete_fungible_ledger_transfers_work() { // Because the new balance will be below ED FungibleLedgerError::InvalidTransfer ); + + // Should be able to create new account with enough balance assert_ok!(ConcreteFungibleLedger::< Runtime, CalamariAssetConfig, @@ -1060,6 +1067,7 @@ fn concrete_fungible_ledger_transfers_work() { NativeTokenExistentialDeposit::get() ); + // Transfer all of your balance without dropping below ED should work assert_ok!(ConcreteFungibleLedger::< Runtime, CalamariAssetConfig, @@ -1069,7 +1077,6 @@ fn concrete_fungible_ledger_transfers_work() { >::NativeAssetId::get(), &bob.clone(), &alice.clone(), - // Transfer a large amount INITIAL_BALANCE - NativeTokenExistentialDeposit::get(), )); current_balance_alice += INITIAL_BALANCE - NativeTokenExistentialDeposit::get(); @@ -1079,8 +1086,9 @@ fn concrete_fungible_ledger_transfers_work() { NativeTokenExistentialDeposit::get() ); + // Transfer tests for non-native assets: + let min_balance = 10u128; - // non-native asset id let asset_metadata = AssetRegistrarMetadata { name: b"Kusama".to_vec(), symbol: b"KSM".to_vec(), @@ -1097,7 +1105,9 @@ fn concrete_fungible_ledger_transfers_work() { source_location.clone(), asset_metadata.clone() ),); - // TODO: change u128::MAX when we start using https://github.com/paritytech/substrate/pull/11241 + + // Register and mint for testing. + // Switch to u128::MAX when we start using https://github.com/paritytech/substrate/pull/11241 let amount = INITIAL_BALANCE; assert_ok!(ConcreteFungibleLedger::< Runtime, @@ -1117,12 +1127,12 @@ fn concrete_fungible_ledger_transfers_work() { amount ); + // Transferring and falling below ED of the asset should not work. assert_err!( CalamariConcreteFungibleLedger::transfer( >::StartNonNativeAssetId::get(), &alice.clone(), &bob.clone(), - // Fail because of ED amount, ), FungibleLedgerError::InvalidTransfer @@ -1135,6 +1145,7 @@ fn concrete_fungible_ledger_transfers_work() { amount ); + // Transferring to empty account without reaching ED of the asset should not work. assert_err!( CalamariConcreteFungibleLedger::transfer( >::StartNonNativeAssetId::get(), @@ -1153,6 +1164,7 @@ fn concrete_fungible_ledger_transfers_work() { amount ); + // Transferring normal amounts should work. assert_ok!(ConcreteFungibleLedger::< Runtime, CalamariAssetConfig, @@ -1179,7 +1191,7 @@ fn concrete_fungible_ledger_transfers_work() { transfer_amount ); - // Switch asset-id + // Transferring invalid asset ID should not work. assert_err!( CalamariConcreteFungibleLedger::transfer( >::DummyAssetId::get(), @@ -1195,6 +1207,7 @@ fn concrete_fungible_ledger_transfers_work() { current_balance_charlie ); + // Transferring unregistered asset ID should not work. assert_err!( CalamariConcreteFungibleLedger::transfer( u32::MAX, From 009974e1ad16f660c310c7c522ba8c2cdae9bb1e Mon Sep 17 00:00:00 2001 From: ghzlatarev Date: Wed, 27 Apr 2022 12:34:20 +0300 Subject: [PATCH 3/4] Comments Signed-off-by: ghzlatarev --- runtime/calamari/tests/integration_tests.rs | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/runtime/calamari/tests/integration_tests.rs b/runtime/calamari/tests/integration_tests.rs index 44629c572..dc7fe65f4 100644 --- a/runtime/calamari/tests/integration_tests.rs +++ b/runtime/calamari/tests/integration_tests.rs @@ -1107,7 +1107,7 @@ fn concrete_fungible_ledger_transfers_work() { ),); // Register and mint for testing. - // Switch to u128::MAX when we start using https://github.com/paritytech/substrate/pull/11241 + // TODO:: Switch to u128::MAX when we start using https://github.com/paritytech/substrate/pull/11241 let amount = INITIAL_BALANCE; assert_ok!(ConcreteFungibleLedger::< Runtime, @@ -1228,6 +1228,8 @@ fn concrete_fungible_ledger_can_deposit_and_mint_works() { .with_balances(vec![(alice.clone(), INITIAL_BALANCE)]) .build() .execute_with(|| { + // Native asset tests: + let new_account = get_account_id_from_seed::("NewAccount"); assert_err!( CalamariConcreteFungibleLedger::can_deposit( @@ -1262,8 +1264,9 @@ fn concrete_fungible_ledger_can_deposit_and_mint_works() { FungibleLedgerError::Overflow ); + // Non-native asset tests: + let min_balance = 10u128; - // non-native asset id let asset_metadata = AssetRegistrarMetadata { name: b"Kusama".to_vec(), symbol: b"KSM".to_vec(), @@ -1362,6 +1365,8 @@ fn concrete_fungible_ledger_can_withdraw_works() { .with_balances(vec![(alice.clone(), INITIAL_BALANCE)]) .build() .execute_with(|| { + // Native asset tests: + assert_err!( CalamariConcreteFungibleLedger::can_withdraw( >::NativeAssetId::get(), @@ -1389,7 +1394,8 @@ fn concrete_fungible_ledger_can_withdraw_works() { FungibleLedgerError::NoFunds ); - // Underflow -> NoFunds -> ReducedToZero -> WouldDie -> Frozen + // Non-native asset tests: + let min_balance = 10u128; let asset_metadata = AssetRegistrarMetadata { name: b"Kusama".to_vec(), From b9262c4ceb9e6ccf515239d808950867324a15e5 Mon Sep 17 00:00:00 2001 From: ghzlatarev Date: Thu, 28 Apr 2022 18:42:34 +0300 Subject: [PATCH 4/4] Wrap DispatchError with InvalidTransfer and InvalidMint errors Signed-off-by: ghzlatarev --- pallets/manta-pay/src/lib.rs | 6 +-- primitives/src/assets.rs | 14 +++--- runtime/calamari/tests/integration_tests.rs | 54 ++++++++++++++++----- 3 files changed, 53 insertions(+), 21 deletions(-) diff --git a/pallets/manta-pay/src/lib.rs b/pallets/manta-pay/src/lib.rs index 788e88df6..257a11630 100644 --- a/pallets/manta-pay/src/lib.rs +++ b/pallets/manta-pay/src/lib.rs @@ -252,7 +252,7 @@ pub mod pallet { pub enum Event { /// Public Transfer Event Transfer { - /// Asset Transfered + /// Asset Transferred asset: Asset, /// Source Account @@ -302,7 +302,7 @@ pub mod pallet { /// Balance Low /// - /// Attempted to withdraw from balance which was smaller than the withdrawl amount. + /// Attempted to withdraw from balance which was smaller than the withdrawal amount. BalanceLow, /// Invalid Serialized Form @@ -450,7 +450,7 @@ pub mod pallet { FungibleLedgerError::ReducedToZero(_) => Self::PublicUpdateReducedToZero, FungibleLedgerError::NoFunds => Self::PublicUpdateNoFunds, FungibleLedgerError::WouldDie => Self::PublicUpdateWouldDie, - FungibleLedgerError::InvalidTransfer => Self::PublicUpdateInvalidTransfer, + FungibleLedgerError::InvalidTransfer(_e) => Self::PublicUpdateInvalidTransfer, _ => Self::InternalLedgerError, } } diff --git a/primitives/src/assets.rs b/primitives/src/assets.rs index e2157b5bc..54db53f48 100644 --- a/primitives/src/assets.rs +++ b/primitives/src/assets.rs @@ -32,7 +32,7 @@ use frame_support::{ }; use scale_info::TypeInfo; use sp_core::H160; -use sp_runtime::{traits::Member, DispatchResult}; +use sp_runtime::{traits::Member, DispatchError, DispatchResult}; use sp_std::{borrow::Borrow, marker::PhantomData, prelude::Vec}; use xcm::{ v1::{Junctions, MultiLocation}, @@ -250,14 +250,14 @@ where } /// Fungible Ledger Error -#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)] +#[derive(Clone, Copy, Debug, Eq, PartialEq)] pub enum FungibleLedgerError { /// Invalid Asset Id InvalidAssetId, /// Deposit couldn't happen due to the amount being too low. This is usually because the /// account doesn't yet exist and the deposit wouldn't bring it to at least the minimum needed - /// for existance. + /// for existence. BelowMinimum, /// Deposit cannot happen since the account cannot be created (usually because it's a consumer @@ -294,10 +294,10 @@ pub enum FungibleLedgerError { WouldDie, /// Unable to Mint an Asset - InvalidMint, + InvalidMint(DispatchError), /// Unable to Transfer an Asset - InvalidTransfer, + InvalidTransfer(DispatchError), } impl FungibleLedgerError { @@ -439,7 +439,7 @@ where >::deposit_creating(beneficiary, amount); } else { >::mint_into(asset_id, beneficiary, amount) - .map_err(|_| FungibleLedgerError::InvalidMint)?; + .map_err(|e| FungibleLedgerError::InvalidMint(e))?; } Ok(()) } @@ -469,6 +469,6 @@ where ) .map(|_| ()) } - .map_err(|_| FungibleLedgerError::InvalidTransfer) + .map_err(|e| FungibleLedgerError::InvalidTransfer(e)) } } diff --git a/runtime/calamari/tests/integration_tests.rs b/runtime/calamari/tests/integration_tests.rs index dc7fe65f4..e23a6cb3a 100644 --- a/runtime/calamari/tests/integration_tests.rs +++ b/runtime/calamari/tests/integration_tests.rs @@ -989,8 +989,14 @@ fn concrete_fungible_ledger_transfers_work() { &charlie.clone(), INITIAL_BALANCE + 1, ), - // Not enough funds - FungibleLedgerError::InvalidTransfer + FungibleLedgerError::InvalidTransfer(DispatchError::Module { + index: ::PalletInfo::index::< + Balances, + >() + .unwrap() as u8, + error: 2, + message: Some("InsufficientBalance") + }) ); assert_eq!(Balances::free_balance(alice.clone()), current_balance_alice); assert_eq!( @@ -1006,8 +1012,14 @@ fn concrete_fungible_ledger_transfers_work() { &charlie.clone(), INITIAL_BALANCE, ), - // Because keep_alive is set to true - FungibleLedgerError::InvalidTransfer + FungibleLedgerError::InvalidTransfer(DispatchError::Module { + index: ::PalletInfo::index::< + Balances, + >() + .unwrap() as u8, + error: 4, + message: Some("KeepAlive") + }) ); assert_eq!(Balances::free_balance(alice.clone()), current_balance_alice); assert_eq!( @@ -1044,8 +1056,14 @@ fn concrete_fungible_ledger_transfers_work() { &new_account.clone(), NativeTokenExistentialDeposit::get() - 1, ), - // Because the new balance will be below ED - FungibleLedgerError::InvalidTransfer + FungibleLedgerError::InvalidTransfer(DispatchError::Module { + index: ::PalletInfo::index::< + Balances, + >() + .unwrap() as u8, + error: 3, + message: Some("ExistentialDeposit") + }) ); // Should be able to create new account with enough balance @@ -1135,7 +1153,14 @@ fn concrete_fungible_ledger_transfers_work() { &bob.clone(), amount, ), - FungibleLedgerError::InvalidTransfer + FungibleLedgerError::InvalidTransfer(DispatchError::Module { + index: ::PalletInfo::index::< + Assets, + >() + .unwrap() as u8, + error: 0, + message: Some("BalanceLow") + }) ); assert_eq!( Assets::balance( @@ -1145,16 +1170,16 @@ fn concrete_fungible_ledger_transfers_work() { amount ); - // Transferring to empty account without reaching ED of the asset should not work. assert_err!( CalamariConcreteFungibleLedger::transfer( >::StartNonNativeAssetId::get(), &alice.clone(), &bob.clone(), - // Fail because of ED min_balance - 1, ), - FungibleLedgerError::InvalidTransfer + FungibleLedgerError::InvalidTransfer(DispatchError::Token( + sp_runtime::TokenError::BelowMinimum + )) ); assert_eq!( Assets::balance( @@ -1215,7 +1240,14 @@ fn concrete_fungible_ledger_transfers_work() { &charlie.clone(), transfer_amount, ), - FungibleLedgerError::InvalidTransfer + FungibleLedgerError::InvalidTransfer(DispatchError::Module { + index: ::PalletInfo::index::< + Assets, + >() + .unwrap() as u8, + error: 3, + message: Some("Unknown") + }) ); }); }