chore: split up pox-2-rosetta tests (#1461)

* chore: split up pox-2-rosetta tests

* chore: split up pox-2-rosetta test suites into smaller units

Author: zone117x

.github/workflows/ci.yml

@@ -411,7 +411,9 @@ jobs:
           pox-2-delegate-aggregation,
           pox-2-delegate-stacking,
           pox-2-stack-extend-increase,
-          pox-2-rosetta
+          pox-2-rosetta-btc-addr-types,
+          pox-2-rosetta-cycle-phases,
+          pox-2-rosetta-segwit,
         ]
     runs-on: ubuntu-latest
     steps:

src/tests-2.1/pox-2-rosetta-btc-addr-types.ts

@@ -0,0 +1,81 @@
+import { getBitcoinAddressFromKey } from '../ec-helpers';
+import { testnetKeys } from '../api/routes/debug';
+import {
+  fetchGet,
+  stackStxWithRosetta,
+  standByUntilBurnBlock,
+  testEnv,
+} from '../test-utils/test-helpers';
+import { CoreRpcPoxInfo } from '../core-rpc/client';
+import { DbTxStatus } from '../datastore/common';
+import { BurnchainRewardSlotHolderListResponse } from '@stacks/stacks-blockchain-api-types';
+
+const BTC_ADDRESS_CASES = [
+  { addressFormat: 'p2pkh' },
+  { addressFormat: 'p2sh' },
+  { addressFormat: 'p2sh-p2wpkh' },
+  { addressFormat: 'p2sh-p2wsh' },
+  { addressFormat: 'p2wpkh' },
+  { addressFormat: 'p2wsh' },
+  { addressFormat: 'p2tr' },
+] as const;
+
+describe.each(BTC_ADDRESS_CASES)(
+  'PoX-2 - Rosetta - Stack with BTC address format $addressFormat',
+  ({ addressFormat }) => {
+    let poxInfo: CoreRpcPoxInfo;
+    const account = testnetKeys[1];
+    let bitcoinAddress: string;
+
+    beforeAll(() => {
+      bitcoinAddress = getBitcoinAddressFromKey({
+        privateKey: account.secretKey,
+        network: 'testnet',
+        addressFormat,
+      });
+    });
+
+    test('Standby for next cycle', async () => {
+      poxInfo = await testEnv.client.getPox();
+      await standByUntilBurnBlock(poxInfo.next_cycle.reward_phase_start_block_height); // a good time to stack
+      // await standByForPoxCycle(); DON'T USE THIS!!! <cycle>.id is lying to you!
+    });
+
+    test('Perform stack-stx using Rosetta', async () => {
+      poxInfo = await testEnv.client.getPox();
+      expect(poxInfo.next_cycle.blocks_until_reward_phase).toBe(poxInfo.reward_cycle_length); // cycle just started
+
+      const ustxAmount = BigInt(Math.round(Number(poxInfo.min_amount_ustx) * 1.1).toString());
+      const cycleCount = 1;
+
+      const rosettaStackStx = await stackStxWithRosetta({
+        btcAddr: bitcoinAddress,
+        stacksAddress: account.stacksAddress,
+        pubKey: account.pubKey,
+        privateKey: account.secretKey,
+        cycleCount,
+        ustxAmount,
+      });
+      expect(rosettaStackStx.tx.status).toBe(DbTxStatus.Success);
+      expect(rosettaStackStx.constructionMetadata.metadata.contract_name).toBe('pox-2');
+    });
+
+    test('Validate reward set received', async () => {
+      // todo: is it correct that the reward set is only available after/in the 2nd block of a reward phase?
+      await standByUntilBurnBlock(poxInfo.next_cycle.reward_phase_start_block_height + 1); // time to check reward sets
+
+      poxInfo = await testEnv.client.getPox();
+      const rewardSlotHolders = await fetchGet<BurnchainRewardSlotHolderListResponse>(
+        `/extended/v1/burnchain/reward_slot_holders/${bitcoinAddress}`
+      );
+      expect(rewardSlotHolders.total).toBe(1);
+      expect(rewardSlotHolders.results[0].address).toBe(bitcoinAddress);
+      expect(rewardSlotHolders.results[0].burn_block_height).toBe(
+        poxInfo.current_burnchain_block_height
+      );
+      expect(poxInfo.next_cycle.blocks_until_reward_phase).toBe(
+        poxInfo.reward_cycle_length - (2 - 1) // aka 2nd / nth block of reward phase (zero-indexed)
+      );
+    });
+  }
+);

src/tests-2.1/pox-2-rosetta-cycle-phases.ts

@@ -0,0 +1,54 @@
+import { testnetKeys } from '../api/routes/debug';
+import { stackStxWithRosetta, standByUntilBurnBlock, testEnv } from '../test-utils/test-helpers';
+
+const REWARD_CYCLE_LENGTH = 5; // assuming regtest
+const BLOCK_SHIFT_COUNT: { shift: number }[] = [];
+for (let shift = 0; shift < REWARD_CYCLE_LENGTH; shift++) {
+  BLOCK_SHIFT_COUNT.push({ shift });
+}
+
+const account = testnetKeys[1];
+const btcAddr = '2N74VLxyT79VGHiBK2zEg3a9HJG7rEc5F3o';
+
+describe.each(BLOCK_SHIFT_COUNT)(
+  'PoX-2 - Rosetta - Stack on any phase of cycle $shift',
+  ({ shift }) => {
+    test('Standby for cycle phase', async () => {
+      const poxInfo = await testEnv.client.getPox();
+
+      const blocksUntilNextCycle =
+        poxInfo.next_cycle.blocks_until_reward_phase % poxInfo.reward_cycle_length;
+      const startHeight =
+        (poxInfo.current_burnchain_block_height as number) + blocksUntilNextCycle + shift;
+
+      if (startHeight !== poxInfo.current_burnchain_block_height) {
+        // only stand-by if we're not there yet
+        await standByUntilBurnBlock(startHeight);
+      }
+    });
+
+    test('Rosetta - stack-stx tx', async () => {
+      const poxInfo = await testEnv.client.getPox();
+      const ustxAmount = BigInt(poxInfo.current_cycle.min_threshold_ustx * 1.2);
+      expect((poxInfo.current_burnchain_block_height as number) % poxInfo.reward_cycle_length).toBe(
+        shift
+      );
+
+      await stackStxWithRosetta({
+        stacksAddress: account.stacksAddress,
+        privateKey: account.secretKey,
+        pubKey: account.pubKey,
+        cycleCount: 1,
+        ustxAmount,
+        btcAddr,
+      });
+    });
+
+    test('Wait for unlock', async () => {
+      const coreBalance = await testEnv.client.getAccount(account.stacksAddress);
+      expect(coreBalance.unlock_height).toBeGreaterThan(0);
+
+      await standByUntilBurnBlock(coreBalance.unlock_height + 1);
+    });
+  }
+);