git.delta.rocks / unique-network / refs/commits / c52f33f18ea3

--- a/tests/src/app-promotion.test.ts
+++ b/tests/src/app-promotion.test.ts
@@ -37,6 +37,9 @@
 let nominal: bigint;
 const palletAddress = calculatePalleteAddress('appstake');
 let accounts: IKeyringPair[] = [];
+const LOCKING_PERIOD = 20n; // 20 blocks of relay
+const UNLOCKING_PERIOD = 10n; // 20 blocks of parachain
+const rewardAvailableInBlock = (stakedInBlock: bigint) => (stakedInBlock - stakedInBlock % LOCKING_PERIOD) + (LOCKING_PERIOD * 2n);
 
 before(async function () {
   await usingPlaygrounds(async (helper, privateKeyWrapper) => {
@@ -66,7 +69,6 @@
       expect (await helper.balance.getSubstrateFull(staker.address)).to.contain({miscFrozen: 100n * nominal, feeFrozen: 100n * nominal, reserved: 0n});
       await expect(helper.balance.transferToSubstrate(staker, recepient.address, 900n * nominal)).to.be.rejected;
       
-      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(100n * nominal);
       expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(100n * nominal);
       expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);
       // it is potentially flaky test. Promotion can credited some tokens. Maybe we need to use closeTo? 
@@ -74,7 +76,6 @@
 
       
       await helper.staking.stake(staker, 200n * nominal);
-      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(300n * nominal);
       expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(300n * nominal);
       expect((await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map((x) => x[1])).to.be.deep.equal([100n * nominal, 200n * nominal]);
     });
@@ -83,7 +84,6 @@
   it('should allow to create maximum 10 stakes for account', async () => {
     await usingPlaygrounds(async (helper) => {
       const [staker] = await helper.arrange.createAccounts([2000n], alice);
-      console.log(staker.address);
       for (let i = 0; i < 10; i++) {
         await helper.staking.stake(staker, 100n * nominal);
       }
@@ -147,14 +147,14 @@
   });
 
   it('should unlock balance after unlocking period ends and remove it from "pendingUnstake"', async () => {
-    // TODO Flaky test
     await usingPlaygrounds(async (helper) => {
       const staker = accounts.pop()!;
       await helper.staking.stake(staker, 100n * nominal);
       await helper.staking.unstake(staker);
+      const unstakedInBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}))[0][0];
 
       // Wait for unstaking period. Balance now free ~1000; reserved, frozen, miscFrozeb: 0n
-      await waitForRelayBlock(helper.api!, 20);
+      await helper.wait.forParachainBlockNumber(unstakedInBlock);
       expect(await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, miscFrozen: 0n, feeFrozen: 0n});
       expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);
 
@@ -181,6 +181,7 @@
      
       // Can unstake multiple stakes
       await helper.staking.unstake(staker);
+      const unstakingBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address}))[0][0];
       pendingUnstake = await helper.staking.getPendingUnstake({Substrate: staker.address});
       unstakedPerBlock = (await helper.staking.getPendingUnstakePerBlock({Substrate: staker.address})).map(stake => stake[1]);
       stakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(stake => stake[1]);
@@ -189,7 +190,7 @@
       expect(unstakedPerBlock).to.be.deep.equal([600n * nominal]);
 
       expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 600n * nominal, feeFrozen: 0n, miscFrozen: 0n});
-      await waitForRelayBlock(helper.api!, 20);
+      await helper.wait.forParachainBlockNumber(unstakingBlock);
       expect (await helper.balance.getSubstrateFull(staker.address)).to.deep.contain({reserved: 0n, feeFrozen: 0n, miscFrozen: 0n});
       expect (await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n);
     });
@@ -202,7 +203,6 @@
       // unstake has no effect if no stakes at all
       await helper.staking.unstake(staker);
       expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(0n);
-      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(0n);
       expect(await helper.balance.getSubstrate(staker.address) / nominal).to.be.equal(999n); // TODO bigint closeTo helper
 
       // TODO stake() unstake() waitUnstaked() unstake();
@@ -213,7 +213,6 @@
       await helper.staking.unstake(staker);
 
       expect(await helper.staking.getPendingUnstake({Substrate: staker.address})).to.be.equal(100n * nominal);
-      expect(await helper.staking.getTotalStakingLocked({Substrate: staker.address})).to.be.equal(100n * nominal);
       expect(await helper.staking.getTotalStaked({Substrate: staker.address})).to.be.equal(0n);
     });
   });
@@ -246,8 +245,6 @@
       }));
     });
   });
-
-  // TODO for different accounts in one block is possible
 });
 
 describe('Admin adress', () => {
@@ -636,13 +633,16 @@
   });
 
   it('should credit 0.05% for staking period', async () => {    
-    // TODO flaky test
     await usingPlaygrounds(async helper => {
       const staker = accounts.pop()!;
       
       await helper.staking.stake(staker, 100n * nominal);
       await helper.staking.stake(staker, 200n * nominal);
-      await waitForRelayBlock(helper.api!, 30);
+
+      // wair rewards are available:
+      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[1][0];
+      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock));
+
       await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
 
       const totalStakedPerBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address})).map(s => s[1]);
@@ -651,21 +651,20 @@
   });
 
   it('shoud be paid for more than one period if payments was missed', async () => {
-    // TODO flaky test
     await usingPlaygrounds(async (helper) => {
       const staker = accounts.pop()!;
 
       await helper.staking.stake(staker, 100n * nominal);
-      await helper.staking.stake(staker, 200n * nominal);
+      // wait for two rewards are available:
+      const stakedInBlock = (await helper.staking.getTotalStakedPerBlock({Substrate: staker.address}))[0][0];
+      await helper.wait.forRelayBlockNumber(rewardAvailableInBlock(stakedInBlock) + LOCKING_PERIOD);
 
-      await waitForRelayBlock(helper.api!, 55);
       await helper.signTransaction(palletAdmin, helper.api!.tx.appPromotion.payoutStakers(100));
       const stakedPerBlock = await helper.staking.getTotalStakedPerBlock({Substrate: staker.address});
-      expect(stakedPerBlock[0][1]).to.be.equal(calculateIncome(100n * nominal, 10n, 2));
-      expect(stakedPerBlock[1][1]).to.be.equal(calculateIncome(200n * nominal, 10n, 2));
+      const frozenBalanceShouldBe = calculateIncome(100n * nominal, 10n, 2);
+      expect(stakedPerBlock[0][1]).to.be.equal(frozenBalanceShouldBe);
 
       const stakerFullBalance = await helper.balance.getSubstrateFull(staker.address);
-      const frozenBalanceShouldBe = calculateIncome(300n * nominal, 10n, 2);
 
       expect(stakerFullBalance).to.contain({reserved: 0n, feeFrozen: frozenBalanceShouldBe, miscFrozen: frozenBalanceShouldBe});
     });
@@ -673,7 +672,7 @@
   
   it('should not be credited for unstaked (reserved) balance', async () => {
     await usingPlaygrounds(async helper => {
-      // staker unstakes before rewards has been initialized
+      // staker unstakes before rewards has been payed
       const staker = accounts.pop()!;
       await helper.staking.stake(staker, 100n * nominal);
       await waitForRelayBlock(helper.api!, 40);
@@ -709,6 +708,12 @@
     });
   });
 
+  it('can be paid 1000 rewards in a time', async () => {
+    await usingPlaygrounds(async (helper) => {
+      expect.fail('Test not implemented');
+    });
+  });
+
   it.skip('can handle 40.000 rewards', async () => {
     await usingPlaygrounds(async (helper) => {
       const [donor] = await helper.arrange.createAccounts([7_000_000n], alice);

--- a/tests/src/util/playgrounds/unique.ts
+++ b/tests/src/util/playgrounds/unique.ts
@@ -1980,16 +1980,16 @@
    * @param signer keyring of signer
    * @param amountToUnstake amount of tokens to unstake
    * @param label extra label for log
-   * @returns 
+   * @returns block number where balances will be unlocked
    */
-  async unstake(signer: TSigner, label?: string): Promise<boolean> {
+  async unstake(signer: TSigner, label?: string): Promise<number> {
     if(typeof label === 'undefined') label = `${signer.address}`;
     const unstakeResult = await this.helper.executeExtrinsic(
       signer, 'api.tx.appPromotion.unstake', 
       [], true,
     );
-    // TODO extract info from unstakeResult
-    return true;
+    // TODO extract block number fron events
+    return 1;
   }
 
   async getTotalStaked(address?: ICrossAccountId): Promise<bigint> {
@@ -1997,10 +1997,6 @@
     return (await this.helper.callRpc('api.rpc.appPromotion.totalStaked')).toBigInt();
   }
 
-  async getTotalStakingLocked(address: ICrossAccountId): Promise<bigint> {
-    return (await this.helper.callRpc('api.rpc.appPromotion.totalStakingLocked', [address])).toBigInt();
-  }
-
   async getTotalStakedPerBlock(address: ICrossAccountId): Promise<bigint[][]> {
     return (await this.helper.callRpc('api.rpc.appPromotion.totalStakedPerBlock', [address])).map(([block, amount]: any[]) => [block.toBigInt(), amount.toBigInt()]);
   }
@@ -2447,4 +2443,4 @@
   async burn(signer: TSigner, amount=1n) {
     return await this.collection.burnToken(signer, this.tokenId, amount);
   }
-}
\ No newline at end of file
+}