add realize yield

Author: enthusiastmartin

Cargo.lock

@@ -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

@@ -1,6 +1,6 @@
 [package]
 name = "pallet-gigahdx"
-version = "0.1.0"
+version = "0.1.1"
 description = "Liquid-staking primitive on top of an EVM money market."
 authors = ["GalacticCouncil"]
 edition = "2021"
@@ -37,6 +37,7 @@ sp-runtime = { workspace = true, features = ["std"] }
 pallet-balances = { workspace = true, features = ["std"] }
 orml-traits = { workspace = true, features = ["std"] }
 orml-tokens = { workspace = true, features = ["std"] }
+proptest = { workspace = true }
 
 [features]
 default = ["std"]

pallets/gigahdx/Cargo.toml

@@ -0,0 +1,9 @@
+# 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 5c5f24cc46aaf315e4c96c8576ab2e68d2324771990ecc6f0f73b4d91abde09a # shrinks to ops = [AccrueYield { amount: 30376718729381 }, Stake { who: 0, amount: 1000000595531 }, Stake { who: 1, amount: 1000035632141 }]
+cc 009af515f5b09355d2e4eb70cdb893133d64ac2173877b500c142651be1f9d61 # shrinks to ops = [AccrueYield { amount: 1000000000000 }, Stake { who: 1, amount: 1000000000001 }, Stake { who: 0, amount: 1000000000000 }, RealizeYield { who: 0 }]
+cc ad55fb586f84e4dcf373f15108cbc59aa095517eba93aad82c0140489a351039 # shrinks to prefix = [AccrueYield { amount: 1000000000000 }, Stake { who: 1, amount: 1000000000000 }, RealizeYield { who: 1 }], seed = 1000000000001

pallets/gigahdx/proptest-regressions/tests/invariants.txt

@@ -140,7 +140,8 @@ mod benches {
 		set_dummy_pool::<T>();
 
 		let caller: T::AccountId = whitelisted_caller();
-		let stake_amount: Balance = 100 * ONE;
+		// Must clear legacy `pallet_staking::MinStake` (1_000 UNITS in the runtime).
+		let stake_amount: Balance = 10_000 * ONE;
 		assert_ok!(T::BenchmarkHelper::setup_legacy_staking_position(&caller, stake_amount));
 
 		#[extrinsic_call]
@@ -192,4 +193,29 @@ mod benches {
 		assert_eq!(s.unstaking_count as u32, max - 1);
 		assert!(s.hdx > 0);
 	}
+
+	#[benchmark]
+	fn realize_yield() {
+		assert_ok!(T::BenchmarkHelper::register_assets());
+		set_dummy_pool::<T>();
+
+		let caller: T::AccountId = whitelisted_caller();
+		let amount: Balance = 100 * ONE;
+		fund::<T>(&caller, amount.saturating_mul(10));
+
+		assert_ok!(Pallet::<T>::giga_stake(
+			RawOrigin::Signed(caller.clone()).into(),
+			amount,
+		));
+
+		// Fund the gigapot so total_staked_hdx doubles → rate ≈ 2 → accrued ≈ amount.
+		fund::<T>(&Pallet::<T>::gigapot_account_id(), amount);
+
+		#[extrinsic_call]
+		realize_yield(RawOrigin::Signed(caller.clone()));
+
+		let s = Stakes::<T>::get(&caller).expect("stake recorded");
+		assert_eq!(s.gigahdx, amount);
+		assert!(s.hdx >= amount.saturating_mul(2));
+	}
 }

pallets/gigahdx/src/benchmarking.rs

@@ -128,6 +128,16 @@ pub mod pallet {
 
 	pub const STORAGE_VERSION: StorageVersion = StorageVersion::new(1);
 
+	/// Defensive tripwire bound for `realize_yield`. Aggregate solvency
+	/// guarantees the gigapot covers all accrued yield; a *per-account*
+	/// `realize_yield` can fall a few atomic units short purely from
+	/// cross-user floor-rounding (one staker's clamped negative residual
+	/// nudging another's rate up). Anything beyond this many atomic units is
+	/// an accounting bug, not rounding — `debug_assert` panics so tests and
+	/// fuzzing surface it; release still returns `GigapotInsufficient`.
+	/// 1 µHDX ≫ any realistic rounding accumulation, ≪ any real shortfall.
+	const MAX_GIGAPOT_ROUNDING_SHORTFALL: Balance = 1_000_000;
+
 	#[pallet::pallet]
 	#[pallet::storage_version(STORAGE_VERSION)]
 	pub struct Pallet<T>(_);
@@ -260,6 +270,13 @@ pub mod pallet {
 			hdx_unlocked: Balance,
 			gigahdx_received: Balance,
 		},
+		/// Accrued yield was moved from the gigapot into the caller's locked
+		/// stake principal. `amount` is the HDX transferred and added to
+		/// `Stakes[who].hdx`; `gigahdx` and the exchange rate are unchanged.
+		YieldRealized {
+			who: T::AccountId,
+			amount: Balance,
+		},
 	}
 
 	#[pallet::error]
@@ -308,6 +325,9 @@ pub mod pallet {
 		/// Some HDX is currently frozen (e.g. backing an active reward-eligible
 		/// vote in `pallet-gigahdx-rewards`); release the freeze first.
 		StakeFrozen,
+		/// The gigapot lacks the HDX to cover the caller's accrued yield.
+		/// Only reachable in a drained/floored state, not normal operation.
+		GigapotInsufficient,
 	}
 
 	#[pallet::call]
@@ -558,6 +578,60 @@ pub mod pallet {
 			});
 			Ok(())
 		}
+
+		/// Realize the caller's accrued yield into their locked stake principal.
+		///
+		/// Moves the HDX value the caller's GIGAHDX has gained since it was last
+		/// reconciled (`rate × gigahdx − Stakes[who].hdx`) from the gigapot into
+		/// the caller's account, folds it into `Stakes[who].hdx`, and refreshes
+		/// the lock. GIGAHDX balance and the exchange rate are unchanged. A
+		/// caller with no accrued yield (or no stake) is a successful no-op.
+		///
+		/// Emits `YieldRealized` event when there was yield to realize.
+		///
+		#[pallet::call_index(6)]
+		#[pallet::weight(T::WeightInfo::realize_yield())]
+		#[transactional]
+		pub fn realize_yield(origin: OriginFor<T>) -> DispatchResult {
+			let who = ensure_signed(origin)?;
+
+			let stake = Stakes::<T>::get(&who).unwrap_or_default();
+			let current_value =
+				Self::calculate_hdx_amount_given_gigahdx(stake.gigahdx).map_err(|_| Error::<T>::Overflow)?;
+			let accrued = current_value.saturating_sub(stake.hdx);
+			if accrued == 0 {
+				return Ok(());
+			}
+
+			if T::NativeCurrency::transfer(
+				&Self::gigapot_account_id(),
+				&who,
+				accrued,
+				ExistenceRequirement::AllowDeath,
+			)
+			.is_err()
+			{
+				let gigapot = T::NativeCurrency::free_balance(&Self::gigapot_account_id());
+				let shortfall = accrued.saturating_sub(gigapot);
+				debug_assert!(
+					shortfall <= MAX_GIGAPOT_ROUNDING_SHORTFALL,
+					"realize_yield: gigapot short by {shortfall} (accrued {accrued}, gigapot {gigapot}) \
+					 — exceeds rounding tolerance, indicates an accounting bug"
+				);
+				return Err(Error::<T>::GigapotInsufficient.into());
+			}
+
+			Stakes::<T>::try_mutate(&who, |maybe| -> Result<(), Error<T>> {
+				let s = maybe.get_or_insert_with(StakeRecord::default);
+				s.hdx = s.hdx.checked_add(accrued).ok_or(Error::<T>::Overflow)?;
+				Ok(())
+			})?;
+			TotalLocked::<T>::mutate(|x| *x = x.saturating_add(accrued));
+			Self::refresh_lock(&who)?;
+
+			Self::deposit_event(Event::YieldRealized { who, amount: accrued });
+			Ok(())
+		}
 	}
 
 	impl<T: Config> Pallet<T> {