feat: bonds

Cargo.toml

@@ -30,6 +30,7 @@ members = [
   'pallets/dynamic-fees',
   'pallets/duster',
   'pallets/otc',
+  'pallets/bonds',
   'math',
   'pallets/staking',
   'pallets/democracy',
@@ -68,6 +69,7 @@ pallet-staking = { path = "pallets/staking", default-features = false }
 pallet-democracy= { path = "pallets/democracy", default-features = false }
 pallet-xcm-rate-limiter = { path = "pallets/xcm-rate-limiter", default-features = false }
 warehouse-liquidity-mining = { package = "pallet-liquidity-mining", path = "pallets/liquidity-mining", default-features = false }
+pallet-bonds = { path = "pallets/bonds", default-features = false}
 
 hydra-dx-build-script-utils = { path = "utils/build-script-utils", default-features = false }
 scraper = { path = "scraper", default-features = false }

integration-tests/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "runtime-integration-tests"
-version = "1.9.0"
+version = "1.9.1"
 description = "Integration tests"
 authors = ["GalacticCouncil"]
 edition = "2021"
@@ -18,6 +18,7 @@ hydradx-adapters = { workspace = true }
 pallet-omnipool = { workspace = true }
 pallet-circuit-breaker = { workspace = true }
 pallet-omnipool-liquidity-mining = { workspace = true }
+pallet-bonds = { workspace = true }
 
 # Warehouse dependencies
 pallet-asset-registry = { workspace = true }

integration-tests/src/bonds.rs

@@ -0,0 +1,124 @@
+#![cfg(test)]
+
+use crate::assert_balance;
+use crate::polkadot_test_net::*;
+
+use frame_support::{assert_noop, assert_ok};
+use orml_traits::MultiCurrency;
+use sp_runtime::BoundedVec;
+use xcm_emulator::TestExt;
+
+use hydradx_runtime::{AssetRegistry, Bonds, Currencies, Runtime, RuntimeOrigin};
+use primitives::constants::time::unix_time::MONTH;
+
+#[test]
+fn issue_bonds_should_work_when_issued_for_native_asset() {
+	Hydra::execute_with(|| {
+		// Arrange
+		let amount = 100 * UNITS;
+		let fee = <Runtime as pallet_bonds::Config>::ProtocolFee::get().mul_ceil(amount);
+		let amount_without_fee: Balance = amount.checked_sub(fee).unwrap();
+
+		let maturity = NOW + MONTH;
+
+		// Act
+		let bond_id = AssetRegistry::next_asset_id().unwrap();
+		assert_ok!(Bonds::issue(RuntimeOrigin::signed(ALICE.into()), HDX, amount, maturity));
+
+		// Assert
+		assert_eq!(Bonds::bond(bond_id).unwrap(), (HDX, maturity));
+
+		let bond_asset_details = AssetRegistry::assets(bond_id).unwrap();
+
+		assert_eq!(bond_asset_details.asset_type, pallet_asset_registry::AssetType::Bond);
+		assert!(bond_asset_details.name.is_empty());
+		assert_eq!(bond_asset_details.existential_deposit, NativeExistentialDeposit::get());
+
+		assert_balance!(&ALICE.into(), HDX, ALICE_INITIAL_NATIVE_BALANCE - amount);
+		assert_balance!(&ALICE.into(), bond_id, amount_without_fee);
+
+		assert_balance!(&<Runtime as pallet_bonds::Config>::FeeReceiver::get(), HDX, fee);
+
+		assert_balance!(&Bonds::pallet_account_id(), HDX, amount_without_fee);
+	});
+}
+
+#[test]
+fn issue_bonds_should_work_when_issued_for_shared_asset() {
+	Hydra::execute_with(|| {
+		// Arrange
+		let amount = 100 * UNITS;
+		let fee = <Runtime as pallet_bonds::Config>::ProtocolFee::get().mul_ceil(amount);
+		let amount_without_fee: Balance = amount.checked_sub(fee).unwrap();
+
+		let maturity = NOW + MONTH;
+
+		let bounded_name: BoundedVec<u8, <Runtime as pallet_asset_registry::Config>::StringLimit> =
+			"SHARED".as_bytes().to_vec().try_into().unwrap();
+		let shared_asset_id = AssetRegistry::register_asset(
+			bounded_name,
+			pallet_asset_registry::AssetType::PoolShare(HDX, DOT),
+			1_000,
+			None,
+			None,
+		)
+		.unwrap();
+		assert_ok!(Currencies::deposit(shared_asset_id, &ALICE.into(), amount,));
+
+		// Act
+		let bond_id = AssetRegistry::next_asset_id().unwrap();
+		assert_ok!(Bonds::issue(
+			RuntimeOrigin::signed(ALICE.into()),
+			shared_asset_id,
+			amount,
+			maturity
+		));
+
+		// Assert
+		assert_eq!(Bonds::bond(bond_id).unwrap(), (shared_asset_id, maturity));
+
+		let bond_asset_details = AssetRegistry::assets(bond_id).unwrap();
+
+		assert_eq!(bond_asset_details.asset_type, pallet_asset_registry::AssetType::Bond);
+		assert!(bond_asset_details.name.is_empty());
+		assert_eq!(bond_asset_details.existential_deposit, 1_000);
+
+		assert_balance!(&ALICE.into(), shared_asset_id, 0);
+		assert_balance!(&ALICE.into(), bond_id, amount_without_fee);
+
+		assert_balance!(
+			&<Runtime as pallet_bonds::Config>::FeeReceiver::get(),
+			shared_asset_id,
+			fee
+		);
+
+		assert_balance!(&Bonds::pallet_account_id(), shared_asset_id, amount_without_fee);
+	});
+}
+
+#[test]
+fn issue_bonds_should_not_work_when_issued_for_bond_asset() {
+	Hydra::execute_with(|| {
+		// Arrange
+		let amount = 100 * UNITS;
+		let maturity = NOW + MONTH;
+
+		let bounded_name: BoundedVec<u8, <Runtime as pallet_asset_registry::Config>::StringLimit> =
+			"BOND".as_bytes().to_vec().try_into().unwrap();
+		let underlying_asset_id =
+			AssetRegistry::register_asset(bounded_name, pallet_asset_registry::AssetType::Bond, 1_000, None, None)
+				.unwrap();
+		assert_ok!(Currencies::deposit(underlying_asset_id, &ALICE.into(), amount,));
+
+		// Act & Assert
+		assert_noop!(
+			Bonds::issue(
+				RuntimeOrigin::signed(ALICE.into()),
+				underlying_asset_id,
+				amount,
+				maturity
+			),
+			pallet_bonds::Error::<hydradx_runtime::Runtime>::DisallowedAseet
+		);
+	});
+}

integration-tests/src/lib.rs

@@ -1,3 +1,4 @@
+mod bonds;
 mod call_filter;
 mod circuit_breaker;
 mod cross_chain_transfer;

integration-tests/src/polkadot_test_net.rs

@@ -11,7 +11,7 @@ use frame_support::{
 };
 pub use hydradx_runtime::{AccountId, NativeExistentialDeposit, Treasury, VestingPalletId};
 use pallet_transaction_multi_payment::Price;
-pub use primitives::{constants::chain::CORE_ASSET_ID, AssetId, Balance};
+pub use primitives::{constants::chain::CORE_ASSET_ID, AssetId, Balance, Moment};
 
 use cumulus_primitives_core::ParaId;
 use cumulus_test_relay_sproof_builder::RelayStateSproofBuilder;
@@ -51,6 +51,8 @@ pub const ETH: AssetId = 4;
 pub const BTC: AssetId = 5;
 pub const ACA: AssetId = 6;
 
+pub const NOW: Moment = 1689844300000; // unix time in milliseconds
+
 decl_test_relay_chain! {
 	pub struct PolkadotRelay {
 		Runtime = polkadot_runtime::Runtime,
@@ -186,7 +188,7 @@ pub fn polkadot_ext() -> sp_io::TestExternalities {
 
 pub fn hydra_ext() -> sp_io::TestExternalities {
 	use frame_support::traits::OnInitialize;
-	use hydradx_runtime::{MultiTransactionPayment, Runtime, System};
+	use hydradx_runtime::{MultiTransactionPayment, Runtime, System, Timestamp};
 
 	let stable_amount = 50_000 * UNITS * 1_000_000;
 	let native_amount = 936_329_588_000_000_000;
@@ -224,6 +226,8 @@ pub fn hydra_ext() -> sp_io::TestExternalities {
 			(b"ETH".to_vec(), 1_000u128, Some(ETH)),
 			(b"BTC".to_vec(), 1_000u128, Some(BTC)),
 			(b"ACA".to_vec(), 1_000u128, Some(ACA)),
+			// workaround for next_asset_id() to return correct values
+			(b"DUMMY".to_vec(), 1_000u128, None),
 		],
 		native_asset_name: b"HDX".to_vec(),
 		native_existential_deposit: existential_deposit,
@@ -296,6 +300,7 @@ pub fn hydra_ext() -> sp_io::TestExternalities {
 	let mut ext = sp_io::TestExternalities::new(t);
 	ext.execute_with(|| {
 		System::set_block_number(1);
+		Timestamp::set_timestamp(NOW);
 		// Make sure the prices are up-to-date.
 		MultiTransactionPayment::on_initialize(1);
 	});

pallets/asset-registry/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "pallet-asset-registry"
-version = "2.2.4"
+version = "2.3.0"
 description = "Pallet for asset registry management"
 authors = ["GalacticCouncil"]
 edition = "2021"