Only load relevant rosetta transaction (#1072)

* refactor: loaded relevant tx only

* test: added test for coinbase tx

* refactor: added testMinerRewards

* style: refactored code according to comments

Author: MHassanTariq

src/api/controllers/db-controller.ts

@@ -59,6 +59,8 @@ import {
   DbSmartContract,
   DbSearchResultWithMetadata,
   BaseTx,
+  DbMinerReward,
+  StxUnlockEvent,
 } from '../../datastore/common';
 import {
   unwrapOptional,
@@ -480,6 +482,71 @@ function parseDbBlock(
   return apiBlock;
 }
 
+async function parseRosettaTxDetail(opts: {
+  block_height: number;
+  indexBlockHash: string;
+  tx: DbTx;
+  db: DataStore;
+  minerRewards: DbMinerReward[];
+  unlockingEvents: StxUnlockEvent[];
+}): Promise<RosettaTransaction> {
+  let events: DbEvent[] = [];
+  if (opts.block_height > 1) {
+    // only return events of blocks at height greater than 1
+    const eventsQuery = await opts.db.getTxEvents({
+      txId: opts.tx.tx_id,
+      indexBlockHash: opts.indexBlockHash,
+      limit: 5000,
+      offset: 0,
+    });
+    events = eventsQuery.results;
+  }
+  const operations = await getOperations(
+    opts.tx,
+    opts.db,
+    opts.minerRewards,
+    events,
+    opts.unlockingEvents
+  );
+  const txMemo = parseTransactionMemo(opts.tx);
+  const rosettaTx: RosettaTransaction = {
+    transaction_identifier: { hash: opts.tx.tx_id },
+    operations: operations,
+  };
+  if (txMemo) {
+    rosettaTx.metadata = {
+      memo: txMemo,
+    };
+  }
+  return rosettaTx;
+}
+
+async function getRosettaBlockTxFromDataStore(opts: {
+  tx: DbTx;
+  block: DbBlock;
+  db: DataStore;
+}): Promise<FoundOrNot<RosettaTransaction>> {
+  let minerRewards: DbMinerReward[] = [],
+    unlockingEvents: StxUnlockEvent[] = [];
+
+  if (opts.tx.type_id === DbTxTypeId.Coinbase) {
+    minerRewards = await opts.db.getMinersRewardsAtHeight({
+      blockHeight: opts.block.block_height,
+    });
+    unlockingEvents = await opts.db.getUnlockedAddressesAtBlock(opts.block);
+  }
+
+  const rosettaTx = await parseRosettaTxDetail({
+    block_height: opts.block.block_height,
+    indexBlockHash: opts.tx.index_block_hash,
+    tx: opts.tx,
+    db: opts.db,
+    minerRewards,
+    unlockingEvents,
+  });
+  return { found: true, result: rosettaTx };
+}
+
 async function getRosettaBlockTransactionsFromDataStore(opts: {
   blockHash: string;
   indexBlockHash: string;
@@ -504,28 +571,14 @@ async function getRosettaBlockTransactionsFromDataStore(opts: {
   const transactions: RosettaTransaction[] = [];
 
   for (const tx of txsQuery.result) {
-    let events: DbEvent[] = [];
-    if (blockQuery.result.block_height > 1) {
-      // only return events of blocks at height greater than 1
-      const eventsQuery = await opts.db.getTxEvents({
-        txId: tx.tx_id,
-        indexBlockHash: opts.indexBlockHash,
-        limit: 5000,
-        offset: 0,
-      });
-      events = eventsQuery.results;
-    }
-    const operations = await getOperations(tx, opts.db, minerRewards, events, unlockingEvents);
-    const txMemo = parseTransactionMemo(tx);
-    const rosettaTx: RosettaTransaction = {
-      transaction_identifier: { hash: tx.tx_id },
-      operations: operations,
-    };
-    if (txMemo) {
-      rosettaTx.metadata = {
-        memo: txMemo,
-      };
-    }
+    const rosettaTx = await parseRosettaTxDetail({
+      block_height: blockQuery.result.block_height,
+      indexBlockHash: opts.indexBlockHash,
+      tx,
+      db: opts.db,
+      minerRewards,
+      unlockingEvents,
+    });
     transactions.push(rosettaTx);
   }
 
@@ -540,30 +593,27 @@ export async function getRosettaTransactionFromDataStore(
   if (!txQuery.found) {
     return { found: false };
   }
-  const blockOperations = await getRosettaBlockTransactionsFromDataStore({
-    blockHash: txQuery.result.block_hash,
-    indexBlockHash: txQuery.result.index_block_hash,
-    db,
-  });
-  if (!blockOperations.found) {
+
+  const blockQuery = await db.getBlock({ hash: txQuery.result.block_hash });
+  if (!blockQuery.found) {
     throw new Error(
       `Could not find block for tx: ${txId}, block_hash: ${txQuery.result.block_hash}, index_block_hash: ${txQuery.result.index_block_hash}`
     );
   }
-  const rosettaTx = blockOperations.result.find(
-    op => op.transaction_identifier.hash === txQuery.result.tx_id
-  );
-  if (!rosettaTx) {
+
+  const rosettaTx = await getRosettaBlockTxFromDataStore({
+    tx: txQuery.result,
+    block: blockQuery.result,
+    db,
+  });
+
+  if (!rosettaTx.found) {
     throw new Error(
       `Rosetta block missing operations for tx: ${txId}, block_hash: ${txQuery.result.block_hash}, index_block_hash: ${txQuery.result.index_block_hash}`
     );
   }
-  const result: RosettaTransaction = {
-    transaction_identifier: rosettaTx.transaction_identifier,
-    operations: rosettaTx.operations,
-    metadata: rosettaTx.metadata,
-  };
-  return { found: true, result };
+
+  return rosettaTx;
 }
 
 interface GetTxArgs {

src/test-utils/test-builders.ts

@@ -16,6 +16,7 @@ import {
   DbFtEvent,
   DbMempoolTx,
   DbMicroblockPartial,
+  DbMinerReward,
   DbNftEvent,
   DbSmartContract,
   DbSmartContractEvent,
@@ -66,6 +67,11 @@ const CONTRACT_ABI = {
   fungible_tokens: [],
   non_fungible_tokens: [],
 };
+const MINER_RECIPIENT = 'testAddr2';
+const COINBASE_AMOUNT = 15_000_000_000_000n;
+const TX_FEES_ANCHORED = 1_000_000_000_000n;
+const TX_FEES_STREAMED_CONFIRMED = 2_000_000_000_000n;
+const TX_FEES_STREAMED_PRODUCED = 3_000_000_000_000n;
 
 interface TestBlockArgs {
   block_height?: number;
@@ -411,6 +417,39 @@ function testSmartContractEvent(args?: TestSmartContractEventArgs): DbSmartContr
   };
 }
 
+interface TestMinerRewardArgs {
+  block_hash?: string;
+  index_block_hash?: string;
+  from_index_block_hash?: string;
+  mature_block_height?: number;
+  canonical?: boolean;
+  recipient?: string;
+  coinbase_amount?: bigint;
+  tx_fees_anchored?: bigint;
+  tx_fees_streamed_confirmed?: bigint;
+  tx_fees_streamed_produced?: bigint;
+}
+
+/**
+ * Generate a test miner reward
+ * @param args - Optional miner reward data
+ * @returns `DbMinerReward`
+ */
+function testMinerReward(args?: TestMinerRewardArgs): DbMinerReward {
+  return {
+    block_hash: args?.block_hash ?? BLOCK_HASH,
+    index_block_hash: args?.index_block_hash ?? INDEX_BLOCK_HASH,
+    from_index_block_hash: args?.from_index_block_hash ?? INDEX_BLOCK_HASH,
+    mature_block_height: args?.mature_block_height ?? BLOCK_HEIGHT,
+    canonical: args?.canonical ?? true,
+    recipient: args?.recipient ?? MINER_RECIPIENT,
+    coinbase_amount: args?.coinbase_amount ?? COINBASE_AMOUNT,
+    tx_fees_anchored: args?.tx_fees_anchored ?? TX_FEES_ANCHORED,
+    tx_fees_streamed_confirmed: args?.tx_fees_streamed_confirmed ?? TX_FEES_STREAMED_CONFIRMED,
+    tx_fees_streamed_produced: args?.tx_fees_streamed_produced ?? TX_FEES_STREAMED_PRODUCED,
+  };
+}
+
 /**
  * Builder that creates a test block with any number of transactions and events so populating
  * the DB for testing becomes easier.
@@ -506,6 +545,16 @@ export class TestBlockBuilder {
     return this;
   }
 
+  addMinerReward(args?: TestMinerRewardArgs): TestBlockBuilder {
+    const defaultArgs: TestMinerRewardArgs = {
+      mature_block_height: this.block.block_height,
+      block_hash: this.block.block_hash,
+      index_block_hash: this.block.index_block_hash,
+    };
+    this.data.minerRewards.push(testMinerReward({ ...defaultArgs, ...args }));
+    return this;
+  }
+
   build(): DataStoreBlockUpdateData {
     return this.data;
   }

src/tests-rosetta/api.ts

@@ -5,7 +5,7 @@ import { ApiServer, startApiServer } from '../api/init';
 import * as supertest from 'supertest';
 import { startEventServer } from '../event-stream/event-server';
 import { Server } from 'net';
-import { DbBlock, DbTx, DbMempoolTx, DbTxStatus, DbTxTypeId } from '../datastore/common';
+import { DbBlock, DbTx, DbMempoolTx, DbTxStatus, DbTxTypeId, DataStoreBlockUpdateData, DbMinerReward } from '../datastore/common';
 import * as assert from 'assert';
 import {
   AnchorMode,
@@ -31,7 +31,7 @@ import {
 } from '@stacks/transactions';
 import * as BN from 'bn.js';
 import { StacksCoreRpcClient } from '../core-rpc/client';
-import { bufferToHexPrefixString, timeout } from '../helpers';
+import { bufferToHexPrefixString, I32_MAX, timeout } from '../helpers';
 import {
   RosettaConstructionCombineRequest,
   RosettaConstructionCombineResponse,
@@ -74,6 +74,7 @@ import {
 } from '../rosetta-helpers';
 import { makeSigHashPreSign, MessageSignature } from '@stacks/transactions';
 import { decodeBtcAddress } from '@stacks/stacking';
+import { TestBlockBuilder } from '../test-utils/test-builders';
 
 
 describe('Rosetta API', () => {
@@ -3378,6 +3379,110 @@ describe('Rosetta API', () => {
     );
   })
 
+  test('block/transaction coinbase', async () => {
+    const dbBlock = await db.getCurrentBlock();
+    const blockRes = dbBlock.result ?? undefined;
+    const block = {
+      parent_index_block_hash: blockRes ? blockRes.index_block_hash : '0x00',
+      parent_block_hash: blockRes ? blockRes.block_hash : "0x00",
+      parent_microblock_hash: '',
+      parent_microblock_sequence: 0,
+      block_height: blockRes ? blockRes.block_height + 1 : 1,
+    };
+
+    const tx = {
+      tx_id: '0x1234',
+      tx_index: 4,
+      anchor_mode: AnchorMode.Any,
+      type_id: DbTxTypeId.Coinbase,
+      raw_result: '0x0100000000000000000000000000000001', // u1
+      canonical: true,
+      microblock_canonical: true,
+      microblock_sequence: I32_MAX,
+      microblock_hash: '',
+      parent_index_block_hash: block.parent_microblock_hash,
+      parent_block_hash: block.parent_index_block_hash,
+      post_conditions: Buffer.from([0x01, 0xf5]),
+      fee_rate: 1234n,
+      sender_address: 'sender-addr',
+    };
+
+    const dbMinerReward1 = {
+      canonical: true,
+    };
+
+    const dbMinerReward2 = {
+      canonical: true,
+      recipient: 'testAddr2',
+    };
+
+    const data = new TestBlockBuilder(block)
+      .addTx(tx)
+      .addMinerReward(dbMinerReward1)
+      .addMinerReward(dbMinerReward2)
+      .build();
+
+    await db.update(data);
+    const query1 = await supertest(api.server)
+      .post(`/rosetta/v1/block/transaction`)
+      .send({
+        network_identifier: { blockchain: 'stacks', network: 'testnet' },
+        block_identifier: { index: block.block_height, hash: data.block.block_hash },
+        transaction_identifier: { hash: tx.tx_id },
+      });
+    expect(JSON.parse(query1.text)).toEqual({
+      transaction_identifier: {
+        hash: tx.tx_id
+      },
+      operations: [
+        {
+          operation_identifier: {
+            index: 0
+          },
+          type: "coinbase",
+          status: "success",
+          account: {
+            address: tx.sender_address
+          }
+        },
+        {
+          operation_identifier: {
+            index: 1
+          },
+          status: "success",
+          type: "miner_reward",
+          account: {
+            address: dbMinerReward2.recipient,
+          },
+          amount: {
+            value: "21000000000000",
+            currency: {
+              decimals: 6,
+              symbol: "STX"
+            }
+          }
+        },
+        {
+          operation_identifier: {
+            index: 2
+          },
+          status: "success",
+          type: "miner_reward",
+          account: {
+            address: 'testAddr2',
+          },
+          amount: {
+            value: "21000000000000",
+            currency: {
+              decimals: 6,
+              symbol: "STX"
+            }
+          }
+        }
+      ]
+    })
+  });
+
   /* rosetta construction end */
 
   afterAll(async () => {