test: add rosetta stacking for each block height

Author: janniks

src/test-utils/test-helpers.ts

@@ -263,8 +263,7 @@ export async function standByForTxSuccess(expectedTxId: string): Promise<DbTx> {
   return tx;
 }
 
-// todo: add `export` to this and remove other implementations of this
-async function standByUntilBlock(blockHeight: number): Promise<DbBlock> {
+export async function standByUntilBlock(blockHeight: number): Promise<DbBlock> {
   const dbBlock = await new Promise<DbBlock>(async resolve => {
     const listener: (blockHash: string) => void = async blockHash => {
       const dbBlockQuery = await testEnv.api.datastore.getBlock({ hash: blockHash });

src/tests-2.1-transition/pox-transition.ts

@@ -29,6 +29,7 @@ import {
   getRosettaBlockByBurnBlockHeight,
   stackStxWithRosetta,
   standByForAccountUnlock,
+  standByUntilBlock,
 } from '../test-utils/test-helpers';
 import { decodeClarityValue } from 'stacks-encoding-native-js';
 import { ApiServer } from '../api/init';
@@ -112,43 +113,6 @@ describe('PoX transition tests', () => {
     return tx;
   }
 
-  async function standByUntilBlock(blockHeight: number): Promise<DbBlock> {
-    const dbBlock = await new Promise<DbBlock>(async resolve => {
-      const listener: (blockHash: string) => void = async blockHash => {
-        const dbBlockQuery = await api.datastore.getBlock({ hash: blockHash });
-        if (!dbBlockQuery.found || dbBlockQuery.result.block_height < blockHeight) {
-          return;
-        }
-        api.datastore.eventEmitter.removeListener('blockUpdate', listener);
-        resolve(dbBlockQuery.result);
-      };
-      api.datastore.eventEmitter.addListener('blockUpdate', listener);
-
-      // Check if block height already reached
-      const curHeight = await api.datastore.getCurrentBlockHeight();
-      if (curHeight.found && curHeight.result >= blockHeight) {
-        const dbBlock = await api.datastore.getBlock({ height: curHeight.result });
-        if (!dbBlock.found) {
-          throw new Error('Unhandled missing block');
-        }
-        api.datastore.eventEmitter.removeListener('blockUpdate', listener);
-        resolve(dbBlock.result);
-        return;
-      }
-    });
-
-    // Ensure stacks-node is caught up with processing this block
-    while (true) {
-      const nodeInfo = await client.getInfo();
-      if (nodeInfo.stacks_tip_height >= blockHeight) {
-        break;
-      } else {
-        await timeout(50);
-      }
-    }
-    return dbBlock;
-  }
-
   async function standByUntilBurnBlock(burnBlockHeight: number): Promise<DbBlock> {
     const dbBlock = await new Promise<DbBlock>(async resolve => {
       const listener: (blockHash: string) => void = async blockHash => {

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

@@ -28,6 +28,7 @@ import {
   stackStxWithRosetta,
   standByForAccountUnlock,
   standByForTxSuccess,
+  standByUntilBlock,
   standByUntilBurnBlock,
   testEnv,
   TestEnvContext,
@@ -77,156 +78,6 @@ describe('PoX-2 - Rosetta - Stacking with segwit', () => {
     });
   });
 
-  const rosettaNetwork: NetworkIdentifier = {
-    blockchain: RosettaConstants.blockchain,
-    network: getRosettaNetworkName(ChainID.Testnet),
-  };
-
-  async function fetchRosetta<TPostBody, TRes>(endpoint: string, body: TPostBody) {
-    const result = await supertest(api.server)
-      .post(endpoint)
-      .send(body as any);
-    expect(result.status).toBe(200);
-    expect(result.type).toBe('application/json');
-    return result.body as TRes;
-  }
-
-  async function getRosettaBlockByHeight(blockHeight: number) {
-    const dbBlockQuery = await api.datastore.getBlock({ height: blockHeight });
-    if (!dbBlockQuery.found) {
-      throw new Error(`block ${blockHeight} not found`);
-    }
-    return fetchRosetta<RosettaBlockRequest, RosettaBlockResponse>('/rosetta/v1/block', {
-      network_identifier: { blockchain: 'stacks', network: 'testnet' },
-      block_identifier: { hash: dbBlockQuery.result.block_hash },
-    });
-  }
-
-  async function getRosettaBlockByBurnBlockHeight(burnBlockHeight: number) {
-    const unlockDbBlock = await api.datastore.getBlockByBurnBlockHeight(burnBlockHeight);
-    expect(unlockDbBlock.found).toBeTruthy();
-    return fetchRosetta<RosettaBlockRequest, RosettaBlockResponse>('/rosetta/v1/block', {
-      network_identifier: { blockchain: 'stacks', network: 'testnet' },
-      block_identifier: { hash: unlockDbBlock.result!.block_hash },
-    });
-  }
-
-  async function getRosettaAccountBalance(stacksAddress: string, atBlockHeight?: number) {
-    const req: RosettaAccountBalanceRequest = {
-      network_identifier: { blockchain: 'stacks', network: 'testnet' },
-      account_identifier: { address: stacksAddress },
-    };
-    if (atBlockHeight) {
-      req.block_identifier = { index: atBlockHeight };
-    }
-    const account = await fetchRosetta<RosettaAccountBalanceRequest, RosettaAccountBalanceResponse>(
-      '/rosetta/v1/account/balance',
-      req
-    );
-    // Also query for locked balance, requires specifying a special constant sub_account
-    req.account_identifier.sub_account = { address: RosettaConstants.StackedBalance };
-    const locked = await fetchRosetta<RosettaAccountBalanceRequest, RosettaAccountBalanceResponse>(
-      '/rosetta/v1/account/balance',
-      req
-    );
-    return {
-      account,
-      locked,
-    };
-  }
-
-  async function stackStxWithRosetta(opts: {
-    btcAddr: string;
-    stacksAddress: string;
-    pubKey: string;
-    privateKey: string;
-    cycleCount: number;
-    ustxAmount: bigint;
-  }) {
-    const stackingOperations: RosettaOperation[] = [
-      {
-        operation_identifier: { index: 0, network_index: 0 },
-        related_operations: [],
-        type: 'stack_stx',
-        account: { address: opts.stacksAddress, metadata: {} },
-        amount: {
-          value: '-' + opts.ustxAmount.toString(),
-          currency: { symbol: 'STX', decimals: 6 },
-          metadata: {},
-        },
-        metadata: {
-          number_of_cycles: opts.cycleCount,
-          pox_addr: opts.btcAddr,
-        },
-      },
-      {
-        operation_identifier: { index: 1, network_index: 0 },
-        related_operations: [],
-        type: 'fee',
-        account: { address: opts.stacksAddress, metadata: {} },
-        amount: { value: '10000', currency: { symbol: 'STX', decimals: 6 } },
-      },
-    ];
-
-    // preprocess
-    const preprocessResult = await fetchRosetta<
-      RosettaConstructionPreprocessRequest,
-      RosettaConstructionPreprocessResponse
-    >('/rosetta/v1/construction/preprocess', {
-      network_identifier: rosettaNetwork,
-      operations: stackingOperations,
-      metadata: {},
-      max_fee: [{ value: '12380898', currency: { symbol: 'STX', decimals: 6 }, metadata: {} }],
-      suggested_fee_multiplier: 1,
-    });
-
-    // metadata
-    const metadataResult = await fetchRosetta<
-      RosettaConstructionMetadataRequest,
-      RosettaConstructionMetadataResponse
-    >('/rosetta/v1/construction/metadata', {
-      network_identifier: rosettaNetwork,
-      options: preprocessResult.options!, // using options returned from preprocess
-      public_keys: [{ hex_bytes: opts.pubKey, curve_type: 'secp256k1' }],
-    });
-
-    // payload
-    const payloadsResult = await fetchRosetta<
-      RosettaConstructionPayloadsRequest,
-      RosettaConstructionPayloadResponse
-    >('/rosetta/v1/construction/payloads', {
-      network_identifier: rosettaNetwork,
-      operations: stackingOperations, // using same operations as preprocess request
-      metadata: metadataResult.metadata, // using metadata from metadata response
-      public_keys: [{ hex_bytes: opts.pubKey, curve_type: 'secp256k1' }],
-    });
-
-    // sign tx
-    const stacksTx = deserializeTransaction(payloadsResult.unsigned_transaction);
-    const signer = new TransactionSigner(stacksTx);
-    signer.signOrigin(createStacksPrivateKey(opts.privateKey));
-    const signedSerializedTx = Buffer.from(stacksTx.serialize()).toString('hex');
-    const expectedTxId = '0x' + stacksTx.txid();
-
-    // submit
-    const submitResult = await fetchRosetta<
-      RosettaConstructionSubmitRequest,
-      RosettaConstructionSubmitResponse
-    >('/rosetta/v1/construction/submit', {
-      network_identifier: rosettaNetwork,
-      signed_transaction: '0x' + signedSerializedTx,
-    });
-
-    const txStandby = await standByForTxSuccess(expectedTxId);
-
-    return {
-      txId: expectedTxId,
-      tx: txStandby,
-      submitResult,
-      resultMetadata: metadataResult,
-    };
-  }
-
   test('Fund new account for testing', async () => {
     await bitcoinRpcClient.importaddress({ address: btcAddr, label: btcAddr, rescan: false });
 
@@ -283,8 +134,8 @@ describe('PoX-2 - Rosetta - Stacking with segwit', () => {
       ustxAmount: ustxAmount,
     });
 
-    expect(stackingResult.resultMetadata.metadata.contract_name).toBe('pox-2');
-    expect(stackingResult.resultMetadata.metadata.burn_block_height as number).toBeTruthy();
+    expect(stackingResult.constructionMetadata.metadata.contract_name).toBe('pox-2');
+    expect(stackingResult.constructionMetadata.metadata.burn_block_height as number).toBeTruthy();
     expect(stackingResult.submitResult.transaction_identifier.hash).toBe(stackingResult.txId);
     expect(stackingResult.tx.contract_call_contract_id).toBe('ST000000000000000000002AMW42H.pox-2');
   });
@@ -401,8 +252,8 @@ describe('PoX-2 - Rosetta - Stacking with segwit', () => {
       ustxAmount,
     });
 
-    expect(rosettaStackStx.resultMetadata.metadata.contract_name).toBe('pox-2');
-    expect(rosettaStackStx.resultMetadata.metadata.burn_block_height as number).toBeTruthy();
+    expect(rosettaStackStx.constructionMetadata.metadata.contract_name).toBe('pox-2');
+    expect(rosettaStackStx.constructionMetadata.metadata.burn_block_height as number).toBeTruthy();
     expect(rosettaStackStx.submitResult.transaction_identifier.hash).toBe(rosettaStackStx.txId);
     expect(rosettaStackStx.tx.contract_call_contract_id).toBe(
       'ST000000000000000000002AMW42H.pox-2'