Feat/split stake extrinsic #1699 (#1717)

The goal of this PR is to split the `stake` extrinsic into two: `stake` and `provider_boost`
Closes #1707

e2e/capacity/staking.test.ts

@@ -7,7 +7,7 @@ import {
  createKeys, createMsaAndProvider,
  stakeToProvider,
  getNextEpochBlock, TEST_EPOCH_LENGTH,
- CENTS, DOLLARS, createAndFundKeypair
+ CENTS, DOLLARS, createAndFundKeypair, boostProvider
 }
  from "../scaffolding/helpers";
 import { firstValueFrom } from "rxjs";
@@ -280,4 +280,30 @@ describe("Capacity Staking Tests", function () {
  });
  })
  });
+
+ describe('provider_boost()', async () => {
+ let stakeKeys: KeyringPair;
+ let stakeProviderId: u64;
+ let capacityBoostMin: bigint = capacityMin/ 20n; // 5% of the amount
+
+ before(async function () {
+ stakeKeys = createKeys("StakeKeysProvider");
+ stakeProviderId = await createMsaAndProvider(stakeKeys, "SPBoost", accountBalance);
+ });
+
+ it('works, happy path', async () => {
+ await assert.doesNotReject(boostProvider(stakeKeys, stakeProviderId, tokenMinStake));
+
+ // Confirm that the tokens were locked in the stakeKeys account using the query API
+ const stakedAcctInfo = await ExtrinsicHelper.getAccountInfo(stakeKeys.address);
+ assert.equal(stakedAcctInfo.data.frozen, tokenMinStake, `expected ${tokenMinStake} frozen balance, got ${stakedAcctInfo.data.frozen}`)
+
+ // Confirm that the capacity was added to the stakeProviderId using the query API
+ const capacityStaked = (await firstValueFrom(ExtrinsicHelper.api.query.capacity.capacityLedger(stakeProviderId))).unwrap();
+ assert.equal(capacityStaked.remainingCapacity, capacityBoostMin, `expected capacityLedger.remainingCapacity = 1CENT, got ${capacityStaked.remainingCapacity}`);
+ assert.equal(capacityStaked.totalTokensStaked, tokenMinStake, `expected capacityLedger.totalTokensStaked = 1CENT, got ${capacityStaked.totalTokensStaked}`);
+ assert.equal(capacityStaked.totalCapacityIssued, capacityBoostMin, `expected capacityLedger.totalCapacityIssued = 1CENT, got ${capacityStaked.totalCapacityIssued}`);
+ trackedFrozenBalance += tokenMinStake;
+ })
+ })
 })

e2e/scaffolding/extrinsicHelpers.ts

@@ -388,8 +388,12 @@ export class ExtrinsicHelper {
  public static setEpochLength(keys: KeyringPair, epoch_length: any): Extrinsic {
  return new Extrinsic(() => ExtrinsicHelper.api.tx.capacity.setEpochLength(epoch_length), keys, ExtrinsicHelper.api.events.capacity.EpochLengthUpdated);
  }
- public static stake(keys: KeyringPair, target: any, amount: any, stakingType: 'MaximumCapacity' | 'ProviderBoost'): Extrinsic {
- return new Extrinsic(() => ExtrinsicHelper.api.tx.capacity.stake(target, amount, stakingType), keys, ExtrinsicHelper.api.events.capacity.Staked);
+ public static stake(keys: KeyringPair, target: any, amount: any): Extrinsic {
+ return new Extrinsic(() => ExtrinsicHelper.api.tx.capacity.stake(target, amount), keys, ExtrinsicHelper.api.events.capacity.Staked);
+ }
+
+ public static providerBoost(keys: KeyringPair, target: any, amount: any): Extrinsic {
+ return new Extrinsic(() => ExtrinsicHelper.api.tx.capacity.providerBoost(target, amount), keys, ExtrinsicHelper.api.events.capacity.ProviderBoosted);
  }
 
  public static unstake(keys: KeyringPair, target: any, amount: any): Extrinsic {

e2e/scaffolding/helpers.ts

@@ -308,6 +308,22 @@ export async function stakeToProvider(source: KeyringPair, keys: KeyringPair, pr
  return Promise.reject('stakeToProvider: stakeEvent should be ExtrinsicHelper.api.events.capacity.Staked');
  }
 }
+export async function boostProvider(keys: KeyringPair, providerId: u64, tokensToStake: bigint): Promise<void> {
+ const stakeOp = ExtrinsicHelper.providerBoost(keys, providerId, tokensToStake);
+ const [stakeEvent] = await stakeOp.fundAndSend();
+ assert.notEqual(stakeEvent, undefined, 'stakeToProvider: should have returned Stake event');
+
+ if (stakeEvent && ExtrinsicHelper.api.events.capacity.ProviderBoosted.is(stakeEvent)) {
+ let stakedCapacity = stakeEvent.data.capacity;
+
+ let expectedCapacity = tokensToStake/TokenPerCapacity/BoostAdjustment;
+
+ assert.equal(stakedCapacity, expectedCapacity, `stakeToProvider: expected ${expectedCapacity}, got ${stakedCapacity}`);
+ }
+ else {
+ return Promise.reject('stakeToProvider: stakeEvent should be ExtrinsicHelper.api.events.capacity.ProviderBoosted');
+ }
+}
 
 export async function getNextEpochBlock() {
  const epochInfo = await firstValueFrom(ExtrinsicHelper.api.query.capacity.currentEpochInfo());
@@ -417,6 +433,7 @@ export async function getOrCreateAvroChatMessageItemizedSchema(source: KeyringPa
 }
 
 export const TokenPerCapacity = 50n;
+export const BoostAdjustment = 20n; // divide by 20 or 5% of Maximum Capacity
 
 export function assertEvent(events: EventMap, eventName: string) {
  assert(events.hasOwnProperty(eventName));

pallets/capacity/src/benchmarking.rs

@@ -69,11 +69,10 @@ benchmarks! {
  let amount: BalanceOf<T> = T::MinimumStakingAmount::get();
  let capacity: BalanceOf<T> = Capacity::<T>::capacity_generated(amount);
  let target = 1;
- let staking_type = StakingType::MaximumCapacity;
 
  register_provider::<T>(target, "Foo");
 
- }: _ (RawOrigin::Signed(caller.clone()), target, amount, staking_type)
+ }: _ (RawOrigin::Signed(caller.clone()), target, amount)
  verify {
  assert!(StakingAccountLedger::<T>::contains_key(&caller));
  assert!(StakingTargetLedger::<T>::contains_key(&caller, target));
@@ -167,6 +166,22 @@ benchmarks! {
  }.into());
  }
 
+ provider_boost {
+ let caller: T::AccountId = create_funded_account::<T>("account", SEED, 105u32);
+ let amount: BalanceOf<T> = T::MinimumStakingAmount::get();
+ let capacity: BalanceOf<T> = Capacity::<T>::capacity_generated(amount);
+ let target = 1;
+
+ register_provider::<T>(target, "Foo");
+
+ }: _ (RawOrigin::Signed(caller.clone()), target, amount)
+ verify {
+ assert!(StakingAccountLedger::<T>::contains_key(&caller));
+ assert!(StakingTargetLedger::<T>::contains_key(&caller, target));
+ assert!(CapacityLedger::<T>::contains_key(target));
+ assert_last_event::<T>(Event::<T>::ProviderBoosted {account: caller, amount, target, capacity}.into());
+ }
+
  impl_benchmark_test_suite!(Capacity,
  crate::tests::mock::new_test_ext(),
  crate::tests::mock::Test);

pallets/capacity/src/lib.rs

@@ -261,7 +261,7 @@ pub mod pallet {
  #[pallet::event]
  #[pallet::generate_deposit(pub (super) fn deposit_event)]
  pub enum Event<T: Config> {
- /// Tokens have been staked to the Frequency network.
+ /// Tokens have been staked to the Frequency network for Maximized Capacity.
  Staked {
  /// The token account that staked tokens to the network.
  account: T::AccountId,
@@ -313,6 +313,17 @@ pub mod pallet {
  /// The amount in token that was retargeted
  amount: BalanceOf<T>,
  },
+ /// Tokens have been staked on the network for Provider Boosting
+ ProviderBoosted {
+ /// The token account that staked tokens to the network.
+ account: T::AccountId,
+ /// The MSA that a token account targeted to receive Capacity based on this staking amount.
+ target: MessageSourceId,
+ /// An amount that was staked.
+ amount: BalanceOf<T>,
+ /// The Capacity amount issued to the target as a result of the stake.
+ capacity: BalanceOf<T>,
+ },
  }
 
  #[pallet::error]
@@ -382,9 +393,9 @@ pub mod pallet {
  origin: OriginFor<T>,
  target: MessageSourceId,
  amount: BalanceOf<T>,
- staking_type: StakingType,
  ) -> DispatchResult {
  let staker = ensure_signed(origin)?;
+ let staking_type = StakingType::MaximumCapacity;
 
  let (mut staking_account, actual_amount) =
  Self::ensure_can_stake(&staker, &target, &amount, &staking_type)?;
@@ -532,6 +543,44 @@ pub mod pallet {
  });
  Ok(())
  }
+
+ /// Stakes some amount of tokens to the network and generates a comparatively small amount of Capacity
+ /// for the target, and gives periodic rewards to origin.
+ /// ### Errors
+ ///
+ /// - Returns Error::InvalidTarget if attempting to stake to an invalid target.
+ /// - Returns Error::InsufficientStakingAmount if attempting to stake an amount below the minimum amount.
+ /// - Returns Error::CannotChangeStakingType if the staking account exists and staking_type is different
+ #[pallet::call_index(5)]
+ #[pallet::weight(T::WeightInfo::provider_boost())]
+ pub fn provider_boost(
+ origin: OriginFor<T>,
+ target: MessageSourceId,
+ amount: BalanceOf<T>,
+ ) -> DispatchResult {
+ let staker = ensure_signed(origin)?;
+ let staking_type = StakingType::ProviderBoost;
+
+ let (mut staking_account, actual_amount) =
+ Self::ensure_can_stake(&staker, &target, &amount, &staking_type)?;
+
+ let capacity = Self::increase_stake_and_issue_capacity(
+ &staker,
+ &mut staking_account,
+ &target,
+ &actual_amount,
+ &staking_type,
+ )?;
+
+ Self::deposit_event(Event::ProviderBoosted {
+ account: staker,
+ amount: actual_amount,
+ target,
+ capacity,
+ });
+
+ Ok(())
+ }
  }
 }
 

pallets/capacity/src/tests/change_staking_target_tests.rs

@@ -164,18 +164,8 @@ fn check_retarget_multiple_stakers() {
 
  setup_provider(&staker_10k, &from_msa, &647u64, ProviderBoost);
  setup_provider(&staker_500, &to_msa, &293u64, ProviderBoost);
- assert_ok!(Capacity::stake(
- RuntimeOrigin::signed(staker_600.clone()),
- from_msa,
- 479u64,
- MaximumCapacity
- ));
- assert_ok!(Capacity::stake(
- RuntimeOrigin::signed(staker_400.clone()),
- to_msa,
- 211u64,
- MaximumCapacity
- ));
+ assert_ok!(Capacity::stake(RuntimeOrigin::signed(staker_600.clone()), from_msa, 479u64,));
+ assert_ok!(Capacity::stake(RuntimeOrigin::signed(staker_400.clone()), to_msa, 211u64,));
 
  // 647 * .1 * .05 = 3 (rounded down)
  // 293 * .1 * .05 = 1 (rounded down)
@@ -204,12 +194,7 @@ fn do_retarget_deletes_staking_target_details_if_zero_balance() {
 
  // stake additional to provider from another Msa, doesn't matter which type.
  // total staked to from_msa is now 22u64.
- assert_ok!(Capacity::stake(
- RuntimeOrigin::signed(300u64),
- from_msa,
- 12u64,
- MaximumCapacity
- ));
+ assert_ok!(Capacity::stake(RuntimeOrigin::signed(300u64), from_msa, 12u64,));
 
  assert_ok!(Capacity::do_retarget(&staker, &from_msa, &to_msa, &amount, &MaximumCapacity));
 
@@ -362,11 +347,10 @@ fn change_staking_target_test_parametric_validity() {
  setup_provider(&from_account, &from_target, &staked_amount, ProviderBoost);
  setup_provider(&from_account, &to_target, &staked_amount, ProviderBoost);
 
- assert_ok!(Capacity::stake(
+ assert_ok!(Capacity::provider_boost(
  RuntimeOrigin::signed(from_account),
  from_target,
  staked_amount,
- ProviderBoost
  ));
 
  struct TestCase {