test(e2e): rewards test

Author: iadmytro

packages/e2e/local-network/scripts/make-babbage.sh

@@ -165,7 +165,7 @@ $SED -i "${ROOT}/genesis/shelley/genesis.json" \
     -e 's/"slotLength": 1/"slotLength": 0.1/' \
     -e 's/"activeSlotsCoeff": 5.0e-2/"activeSlotsCoeff": 0.1/' \
     -e 's/"securityParam": 2160/"securityParam": 10/' \
-    -e 's/"epochLength": 432000/"epochLength": 100/' \
+    -e 's/"epochLength": 432000/"epochLength": 500/' \
     -e "s/\"maxLovelaceSupply\": 0/\"maxLovelaceSupply\": ${MAX_SUPPLY}/" \
     -e 's/"minFeeA": 1/"minFeeA": 44/' \
     -e 's/"minFeeB": 0/"minFeeB": 155381/' \

packages/e2e/test/local-network/local-network.test.ts

@@ -1,6 +1,8 @@
 import * as envalid from 'envalid';
+import { Awaited } from '@cardano-sdk/util';
+import { Cardano } from '@cardano-sdk/core';
 import { FaucetProvider } from '../../src/FaucetProvider';
-import { SingleAddressWallet } from '@cardano-sdk/wallet';
+import { ObservableWallet, SingleAddressWallet, StakeKeyStatus } from '@cardano-sdk/wallet';
 import { faucetProviderFactory, getLogger, getWallet } from '../../src/factories';
 import { filter, firstValueFrom, map } from 'rxjs';
 
@@ -29,6 +31,55 @@ export const env = envalid.cleanEnv(process.env, {
 
 const logger = getLogger(env.LOGGER_MIN_SEVERITY);
 
+const getWalletStateSnapshot = async (wallet: ObservableWallet) => {
+  const [rewardAccount] = await firstValueFrom(wallet.delegation.rewardAccounts$);
+  const balanceAvailable = await firstValueFrom(wallet.balance.utxo.available$);
+  const balanceTotal = await firstValueFrom(wallet.balance.utxo.total$);
+  const deposit = await firstValueFrom(wallet.balance.rewardAccounts.deposit$);
+  const epoch = await firstValueFrom(wallet.currentEpoch$);
+  const utxoTotal = await firstValueFrom(wallet.utxo.total$);
+  const utxoAvailable = await firstValueFrom(wallet.utxo.available$);
+  return {
+    balance: { available: balanceAvailable, deposit, total: balanceTotal },
+    epoch: epoch.epochNo,
+    isStakeKeyRegistered: rewardAccount.keyStatus === StakeKeyStatus.Registered,
+    rewardAccount,
+    utxo: { available: utxoTotal, total: utxoAvailable }
+  };
+};
+type WalletStateSnapshot = Awaited<ReturnType<typeof getWalletStateSnapshot>>;
+
+const createDelegationCertificates = (
+  { epoch, isStakeKeyRegistered, rewardAccount: { address: rewardAccount } }: WalletStateSnapshot,
+  poolId: Cardano.PoolId
+) => {
+  const stakeKeyHash = Cardano.Ed25519KeyHash.fromRewardAccount(rewardAccount);
+  return [
+    ...(isStakeKeyRegistered
+      ? []
+      : ([
+          {
+            __typename: Cardano.CertificateType.StakeKeyRegistration,
+            stakeKeyHash
+          }
+        ] as Cardano.Certificate[])),
+    { __typename: Cardano.CertificateType.StakeDelegation, epoch, poolId, stakeKeyHash }
+  ] as Cardano.Certificate[];
+};
+
+const generateTxs = async (wallet1: any, wallet2: any) => {
+  const tAdaToSend = 5_000_000n;
+  const [{ address: receivingAddress }] = await firstValueFrom(wallet2.wallet.addresses$);
+  for (let i = 0; i < 100; i++) {
+    const unsignedTxA = await wallet1.wallet.initializeTx({
+      outputs: new Set([{ address: receivingAddress, value: { coins: tAdaToSend } }])
+    });
+
+    const signedTxA = await wallet1.wallet.finalizeTx({ tx: unsignedTxA });
+    await wallet1.wallet.submitTx(signedTxA);
+  }
+};
+
 describe('Local Network', () => {
   let faucetProvider: FaucetProvider;
 
@@ -110,4 +161,67 @@ describe('Local Network', () => {
     wallet1.shutdown();
     wallet2.shutdown();
   });
+
+  it('will receive rewards for delegated tADA', async () => {
+    // Arrange
+    const amountFromFaucet = 100_000_000_000;
+
+    const wallet1 = await getWallet({ env, logger, name: 'Sending Wallet', polling: { interval: 50 } });
+    const wallet2 = await getWallet({ env, logger, name: 'Receiving Wallet', polling: { interval: 50 } });
+
+    await firstValueFrom(wallet1.wallet.syncStatus.isSettled$.pipe(filter((isSettled) => isSettled)));
+    await firstValueFrom(wallet2.wallet.syncStatus.isSettled$.pipe(filter((isSettled) => isSettled)));
+
+    const [{ address: sendingAddress }] = await firstValueFrom(wallet1.wallet.addresses$);
+
+    const waitForEpoch = async (numberOfEpochsToWait: number) => {
+      const currentEpoch = await firstValueFrom(wallet1.wallet.currentEpoch$);
+      return await firstValueFrom(
+        wallet1.wallet.currentEpoch$.pipe(
+          filter(({ epochNo }) => epochNo > currentEpoch.epochNo + numberOfEpochsToWait)
+        )
+      );
+    };
+
+    logger.debug(`Address ${sendingAddress.toString()} will be funded with ${amountFromFaucet} tLovelace.`);
+    await faucetProvider.request(sendingAddress.toString(), amountFromFaucet, 1);
+    await firstValueFrom(wallet1.wallet.balance.utxo.total$.pipe(filter(({ coins }) => coins >= amountFromFaucet)));
+
+    const initialState = await getWalletStateSnapshot(wallet1.wallet);
+
+    const activePools = await wallet1.providers.stakePoolProvider.queryStakePools({
+      filters: { status: [Cardano.StakePoolStatus.Active] },
+      pagination: { limit: 2, startAt: 0 }
+    });
+    const poolId = activePools.pageResults[0].id;
+    expect(poolId).toBeDefined();
+    logger.debug(`Wallet funds will be staked to pool ${poolId}.`);
+    const certificates = createDelegationCertificates(initialState, poolId);
+
+    // Act
+
+    // Create stake tx
+    const unsignedTx = await wallet1.wallet.initializeTx({ certificates });
+    const signedTx = await wallet1.wallet.finalizeTx({ tx: unsignedTx });
+    await wallet1.wallet.submitTx(signedTx);
+
+    let currentEpoch = await firstValueFrom(wallet1.wallet.currentEpoch$);
+    logger.debug(`current epoch - ${currentEpoch.epochNo}`);
+    currentEpoch = await waitForEpoch(1);
+    logger.debug(`waited for epoch - ${currentEpoch.epochNo} to start txs `);
+    // workload for generating fees/rewards
+    await generateTxs(wallet1, wallet2);
+
+    // Assert
+
+    currentEpoch = await waitForEpoch(2);
+    logger.debug(`waited for epoch - ${currentEpoch.epochNo} to check rewards`);
+
+    // wait for rewards
+    const reward = await firstValueFrom(wallet1.wallet.balance.rewardAccounts.rewards$.pipe(filter((r) => r > 0)));
+    logger.debug(`amount of generated rewards - ${reward}`);
+
+    wallet1.wallet.shutdown();
+    wallet2.wallet.shutdown();
+  });
 });