Merge branch 'gigahdx-lock' into gigahdx-liquidations

Author: enthusiastmartin

CLAUDE.md

@@ -147,6 +147,68 @@ Types: `feat`, `fix`, `refactor`, `perf`, `test`, `docs`, `style`, `ci`, `build`
 
 **Branches:** `fix/description` or `feat/description`
 
+## Code comments and docs
+
+Default to **no comment**. Only write one when the *why* is non-obvious — a hidden
+invariant, a surprising decision, a workaround. If removing the comment wouldn't
+confuse a future reader who can see the code, don't write it.
+
+**Never restate what the code already says.** Well-named identifiers and types are
+the documentation. Comments that paraphrase the next line are noise.
+
+### Module / file headers
+One paragraph max. State what lives here; don't enumerate every item or describe
+the flow step-by-step.
+
+### Struct / enum field docs
+Skip the obvious (`pub unstaking: Balance`, `pub voters_count: u32`). Document a
+field only when its semantics are surprising — e.g. it stacks instead of replacing,
+must match an external balance, doubles as an idempotency signal.
+
+### Error variants
+One line each, or none if the name already tells the story. Don't write a
+paragraph explaining the policy that produces the error — that belongs at the
+check site.
+
+### Extrinsic docs
+Follow the Description / Parameters / Emits structure from the "Extrinsic
+documentation" section above, but keep the **Description to 1–2 lines plus at
+most one short paragraph** for genuinely load-bearing context. In particular:
+
+- Do not enumerate `Error` variants in the Description — the `#[pallet::error]`
+  enum is the source of truth.
+- Do not list internal implementation steps ("locks X, then mints Y, then calls
+  Z"). The code shows that.
+- Keep the *why* of any non-obvious constraint (e.g. "refuses while stHDX is in
+  circulation — outstanding aTokens would be stranded").
+
+### Trait method docs
+One line. If the trait-level doc already explains the contract, leave method
+docs out entirely.
+
+### Inline comments inside function bodies
+Reserve for:
+- Non-obvious invariants the next line relies on.
+- Why a defensive branch exists / why an error is intentionally swallowed.
+- Why an unusual construct (`drain_prefix(...).count()` to actually drain,
+  `set_lock` vs `extend_lock`, pre-decrement before an external call) is correct.
+
+Skip:
+- Narrating control flow ("// new record: increment voter count" above
+  `voters_count += 1`).
+- Explaining what a well-named helper does at its call site.
+- Restating the assertion in the next `ensure!`.
+
+### What to keep
+Comments that warn a future reader about something they would otherwise miss:
+- "Must match `LockableAToken.sol`'s `freeBalance` check"
+- "Saturating math — hooks must never block voting"
+- "Pool presence ⇔ allocation has run" (load-bearing idempotency signal)
+- "stHDX invariants — verify on AAVE config change: (1)…(2)…"
+
+If in doubt, delete the comment and see if the code still reads. If it does,
+leave it out.
+
 ## Versioning
 
 - **SemVer** on all crates — bump `Cargo.toml` version on changes

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "runtime-integration-tests"
-version = "1.84.0"
+version = "1.85.0"
 description = "Integration tests"
 authors = ["GalacticCouncil"]
 edition = "2021"

integration-tests/Cargo.toml

@@ -316,6 +316,38 @@ fn giga_unstake_should_create_pending_position_when_called() {
 	});
 }
 
+#[test]
+fn realize_yield_should_fold_accrued_into_principal_when_rate_increased() {
+	TestNet::reset();
+	hydra_live_ext(PATH_TO_SNAPSHOT).execute_with(|| {
+		init_gigahdx();
+		reset_giga_state_for_fixture();
+
+		let alice: AccountId = ALICE.into();
+		assert_ok!(GigaHdx::giga_stake(RuntimeOrigin::signed(alice.clone()), 100 * UNITS));
+
+		// Inject yield into the gigapot so rate = (100 + 100) / 100 = 2.
+		assert_ok!(Balances::force_set_balance(
+			RawOrigin::Root.into(),
+			GigaHdx::gigapot_account_id(),
+			100 * UNITS,
+		));
+
+		let rate_before = GigaHdx::exchange_rate();
+		let stake_before = pallet_gigahdx::Stakes::<Runtime>::get(&alice).expect("stake exists");
+		assert_eq!(stake_before.hdx, 100 * UNITS);
+
+		assert_ok!(GigaHdx::realize_yield(RuntimeOrigin::signed(alice.clone())));
+
+		let stake_after = pallet_gigahdx::Stakes::<Runtime>::get(&alice).expect("stake exists");
+		assert_eq!(stake_after.hdx, 200 * UNITS);
+		assert_eq!(stake_after.gigahdx, stake_before.gigahdx, "gigahdx unchanged");
+		assert_eq!(locked_under_ghdx(&alice), 200 * UNITS);
+		assert_eq!(Balances::free_balance(GigaHdx::gigapot_account_id()), 0);
+		assert_eq!(GigaHdx::exchange_rate(), rate_before, "exchange rate unchanged");
+	});
+}
+
 #[test]
 fn unlock_should_release_lock_when_cooldown_elapsed() {
 	TestNet::reset();

integration-tests/src/gigahdx.rs

@@ -449,3 +449,87 @@ fn sequential_trades_accumulate_slip_within_block() {
 		no_slip_drop
 	);
 }
+
+#[test]
+fn buy_succeeds_when_slip_cap_is_binding() {
+	let buy_amount = 100 * UNITS;
+	let tight_cap = Permill::from_parts(1000); // 0.1%
+
+	TestNet::reset();
+	Hydra::execute_with(|| {
+		init_omnipool();
+		assert_ok!(Omnipool::set_slip_fee(
+			RuntimeOrigin::root(),
+			Some(SlipFeeConfig {
+				max_slip_fee: tight_cap
+			}),
+		));
+
+		let trader = AccountId::from(BOB);
+		assert_ok!(Currencies::update_balance(
+			RuntimeOrigin::root(),
+			trader.clone(),
+			DAI,
+			(10_000_000 * UNITS) as i128,
+		));
+
+		let dai_before = Currencies::free_balance(DAI, &trader);
+		let hdx_before = Currencies::free_balance(HDX, &trader);
+
+		assert_ok!(Omnipool::buy(
+			RuntimeOrigin::signed(trader.clone()),
+			HDX,
+			DAI,
+			buy_amount,
+			u128::MAX,
+		));
+
+		let hdx_received = Currencies::free_balance(HDX, &trader) - hdx_before;
+		assert_eq!(hdx_received, buy_amount);
+
+		let dai_spent = dai_before - Currencies::free_balance(DAI, &trader);
+		assert!(dai_spent > 0);
+	});
+}
+
+#[test]
+fn buy_with_lrna_succeeds_when_slip_cap_is_binding() {
+	let buy_amount = 100 * UNITS;
+	let tight_cap = Permill::from_parts(1000); // 0.1%
+
+	TestNet::reset();
+	Hydra::execute_with(|| {
+		init_omnipool();
+		assert_ok!(Omnipool::set_slip_fee(
+			RuntimeOrigin::root(),
+			Some(SlipFeeConfig {
+				max_slip_fee: tight_cap
+			}),
+		));
+
+		let trader = AccountId::from(BOB);
+		assert_ok!(Currencies::update_balance(
+			RuntimeOrigin::root(),
+			trader.clone(),
+			LRNA,
+			(1_000_000 * UNITS) as i128,
+		));
+
+		let lrna_before = Currencies::free_balance(LRNA, &trader);
+		let dai_before = Currencies::free_balance(DAI, &trader);
+
+		assert_ok!(Omnipool::buy(
+			RuntimeOrigin::signed(trader.clone()),
+			DAI,
+			LRNA,
+			buy_amount,
+			u128::MAX,
+		));
+
+		let dai_received = Currencies::free_balance(DAI, &trader) - dai_before;
+		assert_eq!(dai_received, buy_amount);
+
+		let lrna_spent = lrna_before - Currencies::free_balance(LRNA, &trader);
+		assert!(lrna_spent > 0);
+	});
+}

integration-tests/src/omnipool_slip_fees.rs

@@ -2508,7 +2508,7 @@ fn increase_stake_should_work_when_referendum_ongoing_and_votes_processed() {
 }
 
 #[test]
-fn voting_on_next_referenda_should_process_votes() {
+fn removing_vote_should_process_votes() {
 	TestNet::reset();
 	Hydra::execute_with(|| {
 		init_omnipool();
@@ -2569,27 +2569,41 @@ fn voting_on_next_referenda_should_process_votes() {
 
 		end_referendum();
 
+		let alice_position_id = pallet_staking::Pallet::<hydradx_runtime::Runtime>::get_user_position_id(&ALICE.into())
+			.unwrap()
+			.unwrap();
+
+		// Before remove_vote, the finished vote has not been settled: still recorded in Votes,
+		// no points awarded, and not present in VotesRewarded.
+		let position_before =
+			pallet_staking::Pallet::<hydradx_runtime::Runtime>::get_position(alice_position_id).unwrap();
+		assert!(
+			pallet_staking::Pallet::<hydradx_runtime::Runtime>::get_position_votes(alice_position_id)
+				.votes
+				.iter()
+				.any(|(idx, _)| *idx == r)
+		);
 		assert!(
 			pallet_staking::Pallet::<hydradx_runtime::Runtime>::processed_votes::<AccountId, u32>(ALICE.into(), r)
 				.is_none()
 		);
 
-		let r = begin_referendum();
-		assert_ok!(ConvictionVoting::vote(
+		assert_ok!(ConvictionVoting::remove_vote(
 			hydradx_runtime::RuntimeOrigin::signed(ALICE.into()),
-			r,
-			AccountVote::Standard {
-				vote: Vote {
-					aye: true,
-					conviction: Conviction::Locked6x,
-				},
-				balance: 1_000_000 * UNITS,
-			}
+			Some(ROOT_TRACK),
+			r
 		));
+
+		// After remove_vote, settlement has happened: vote removed from Votes and points awarded.
 		assert!(
-			pallet_staking::Pallet::<hydradx_runtime::Runtime>::processed_votes::<AccountId, u32>(ALICE.into(), 0)
-				.is_some()
+			!pallet_staking::Pallet::<hydradx_runtime::Runtime>::get_position_votes(alice_position_id)
+				.votes
+				.iter()
+				.any(|(idx, _)| *idx == r)
 		);
+		let position_after =
+			pallet_staking::Pallet::<hydradx_runtime::Runtime>::get_position(alice_position_id).unwrap();
+		assert!(position_after.get_action_points() > position_before.get_action_points());
 	});
 }
 

integration-tests/src/staking.rs

@@ -6,7 +6,7 @@ license = 'Apache-2.0'
 name = "hydra-dx-math"
 description = "A collection of utilities to make performing liquidity pool calculations more convenient."
 repository = 'https://github.com/galacticcouncil/hydradx-math'
-version = "13.2.1"
+version = "13.2.2"
 
 [dependencies]
 primitive-types = {  workspace = true }

math/Cargo.toml

@@ -1 +1,2 @@
 cc 22ef4648bbc715696260418b2fb3790628c7788f9258b8b9a4f704dc424ee536 # shrinks to asset_out = AssetReserveState { reserve: 190635865358630188, hub_reserve: 1430674154905521092, shares: 100000000000000000, protocol_shares: 100000000000000000 }, amount = 5307728205712486, asset_fee = Permill(300), imbalance = I129 { value: 8936367638875155, negative: true }
+cc 611689fb0af263ea5f079f78b2907a0d86a5a841e52c6ab6d4c781f5ba4b59d0 # shrinks to asset = AssetReserveState { reserve: 2951077894421946163, hub_reserve: 5203031156877507362, shares: 100000000000000000, protocol_shares: 100000000000000000 }, position = Position { amount: 1000000000, shares: 1000000000, price: (1763095357072293632, 1000000000000000000) }

math/proptest-regressions/omnipool/invariants.txt

@@ -0,0 +1,12 @@
+# Seeds for failure cases proptest has generated in the past. It is
+# automatically read and these particular cases re-run before any
+# novel cases are generated.
+#
+# It is recommended to check this file in to source control so that
+# everyone who runs the test benefits from these saved cases.
+cc 25c9d46027af5640b9cce25c1970d5378de64752dd1c9520f5757251db333d27 # shrinks to pool = [AssetReserve { amount: 368323000000, decimals: 6 }, AssetReserve { amount: 380987625000000, decimals: 6 }, AssetReserve { amount: 488969232000000, decimals: 6 }, AssetReserve { amount: 12656000000, decimals: 6 }], amount = 241, amp = 6682, (idx_in, idx_out) = (1, 3)
+cc b8acd18b42aad7c2bf2fb1869de4f133a49e05a5fd165865f781cadd006488c9
+cc b8ffdc09a03ed41698bc59c46d68585ee05e238c14fd8d53d3b7fb0cedfabe3b
+cc 3b86f211644d954ca6a8212758cd01d579c3b1d0cfe5cc615ff25726df7d1fb0
+cc 63a30c69dc9a73f7cfc9c21fc4cc75e88026f721c3fa9b2b8eaa514e988e2649
+cc 464e37423f75de7afd23eef91ca5b097a1aa5e4f9bd839325571089ef256f924

math/proptest-regressions/stableswap/tests/invariants.txt

@@ -60,7 +60,7 @@ fn high_asset_state() -> impl Strategy<Value = AssetReserveState<Balance>> {
 }
 
 fn trade_amount() -> impl Strategy<Value = Balance> {
-	1_000_000_000..10000 * ONE
+	ONE / 10..10000 * ONE
 }
 
 fn price() -> impl Strategy<Value = FixedU128> {