From 726f1c643d9478fcd822b1691588d47fa038ed7b Mon Sep 17 00:00:00 2001
From: Matthew Little <zone117x@gmail.com>
Date: Wed, 11 Nov 2020 16:04:37 +0100
Subject: [PATCH] feat: integrate stx lock event handling into db

---
 .vscode/launch.json                           |   3 +
 src/api/routes/debug.ts                       | 137 ++++++++++++++++++
 src/datastore/common.ts                       |  11 +-
 src/datastore/memory-store.ts                 |  28 +++-
 src/datastore/postgres-store.ts               |  52 +++++++
 src/event-stream/core-node-message.ts         |  10 +-
 src/event-stream/event-server.ts              |  28 +++-
 .../1605100253938_stx_lock_events.ts          |  53 +++++++
 src/tests/api-tests.ts                        |   2 +
 src/tests/datastore-tests.ts                  |   9 ++
 src/tests/websocket-tests.ts                  |   5 +
 tsconfig.json                                 |   2 +-
 12 files changed, 329 insertions(+), 11 deletions(-)
 create mode 100644 src/migrations/1605100253938_stx_lock_events.ts

diff --git a/.vscode/launch.json b/.vscode/launch.json
index a7a1862b46..441d6fe46f 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -32,6 +32,9 @@
       "type": "node",
       "request": "launch",
       "name": "Launch: mocknet",
+      "skipFiles": [
+        "<node_internals>/**"
+      ],
       "runtimeArgs": ["-r", "ts-node/register/transpile-only", "-r", "tsconfig-paths/register"],
       "args": ["${workspaceFolder}/src/index.ts"],
       "outputCapture": "std",
diff --git a/src/api/routes/debug.ts b/src/api/routes/debug.ts
index 43abe24417..379d19db51 100644
--- a/src/api/routes/debug.ts
+++ b/src/api/routes/debug.ts
@@ -1,5 +1,7 @@
 import * as express from 'express';
 import * as BN from 'bn.js';
+import * as btc from 'bitcoinjs-lib';
+import * as c32check from 'c32check';
 import * as bodyParser from 'body-parser';
 import { addAsync, RouterWithAsync } from '@awaitjs/express';
 import { htmlEscape } from 'escape-goat';
@@ -24,6 +26,10 @@ import {
   TransactionVersion,
   AddressVersion,
   addressToString,
+  ContractCallOptions,
+  uintCV,
+  tupleCV,
+  bufferCV,
 } from '@blockstack/stacks-transactions';
 import { SampleContracts } from '../../sample-data/broadcast-contract-default';
 import { DataStore, DbFaucetRequestCurrency } from '../../datastore/common';
@@ -426,6 +432,137 @@ export function createDebugRouter(db: DataStore): RouterWithAsync {
       );
   });
 
+  const sendPoxHtml = `
+    <style>
+      * { font-family: "Lucida Console", Monaco, monospace; }
+      input {
+        display: block;
+        width: 100%;
+        margin-bottom: 10;
+      }
+    </style>
+    <form action="" method="post">
+      <label for="origin_key">Sender key</label>
+      <input list="origin_keys" name="origin_key" value="${testnetKeys[0].secretKey}">
+      <datalist id="origin_keys">
+        ${testnetKeys.map(k => '<option value="' + k.secretKey + '">').join('\n')}
+      </datalist>
+
+      <label for="recipient_address">Recipient address</label>
+      <input list="recipient_addresses" name="recipient_address" value="${
+        testnetKeys[1].stacksAddress
+      }">
+      <datalist id="recipient_addresses">
+        ${testnetKeys.map(k => '<option value="' + k.stacksAddress + '">').join('\n')}
+      </datalist>
+
+      <label for="stx_amount">uSTX amount</label>
+      <input type="number" id="stx_amount" name="stx_amount" value="5000">
+
+      <label for="memo">Memo</label>
+      <input type="text" id="memo" name="memo" value="hello" maxlength="34">
+
+      <input type="checkbox" id="sponsored" name="sponsored" value="sponsored" style="display:initial;width:auto">
+      <label for="sponsored">Create sponsored transaction</label>
+
+      <input type="submit" value="Submit">
+    </form>
+  `;
+
+  router.getAsync('/broadcast/stack', (req, res) => {
+    res.set('Content-Type', 'text/html').send(sendPoxHtml);
+  });
+
+  function convertBTCAddress(btcAddress: string) {
+    function getAddressHashMode(btcAddress: string) {
+      if (btcAddress.startsWith('bc1') || btcAddress.startsWith('tb1')) {
+        const { data } = btc.address.fromBech32(btcAddress);
+        if (data.length === 32) {
+          return AddressHashMode.SerializeP2WSH;
+        } else {
+          return AddressHashMode.SerializeP2WPKH;
+        }
+      } else {
+        const { version } = btc.address.fromBase58Check(btcAddress);
+        switch (version) {
+          case 0:
+            return AddressHashMode.SerializeP2PKH;
+          case 111:
+            return AddressHashMode.SerializeP2PKH;
+          case 5:
+            return AddressHashMode.SerializeP2SH;
+          case 196:
+            return AddressHashMode.SerializeP2SH;
+          default:
+            throw new Error('Invalid pox address version');
+        }
+      }
+    }
+    const hashMode = getAddressHashMode(btcAddress);
+    if (btcAddress.startsWith('bc1') || btcAddress.startsWith('tb1')) {
+      const { data } = btc.address.fromBech32(btcAddress);
+      return {
+        hashMode,
+        data,
+      };
+    } else {
+      const { hash } = btc.address.fromBase58Check(btcAddress);
+      return {
+        hashMode,
+        data: hash,
+      };
+    }
+  }
+
+  router.postAsync('/broadcast/stack', async (req, res) => {
+    const { origin_key, recipient_address, stx_amount, memo } = req.body;
+    const client = new StacksCoreRpcClient();
+    const coreInfo = await client.getInfo();
+    const poxInfo = await client.getPox();
+    const minStxAmount = BigInt(poxInfo.min_amount_ustx);
+    const sender = testnetKeys.filter(t => t.secretKey === origin_key)[0];
+    const accountBalance = await client.getAccountBalance(sender.stacksAddress);
+    if (accountBalance < minStxAmount) {
+      throw new Error(
+        `Min requirement pox amount is ${minStxAmount} but account balance is only ${accountBalance}`
+      );
+    }
+    const [contractAddress, contractName] = poxInfo.contract_id.split('.');
+    const btcAddr = c32check.c32ToB58(sender.stacksAddress);
+    const { hashMode, data } = convertBTCAddress(btcAddr);
+    const cycles = 3;
+    const txOptions: ContractCallOptions = {
+      senderKey: sender.secretKey,
+      contractAddress,
+      contractName,
+      functionName: 'stack-stx',
+      functionArgs: [
+        uintCV(minStxAmount.toString()),
+        tupleCV({
+          hashbytes: bufferCV(data),
+          version: bufferCV(new BN(hashMode).toBuffer()),
+        }),
+        uintCV(coreInfo.burn_block_height),
+        uintCV(cycles),
+      ],
+      network: stacksNetwork,
+    };
+    const tx = await makeContractCall(txOptions);
+    const expectedTxId = tx.txid();
+    const serializedTx = tx.serialize();
+    const { txId } = await sendCoreTx(serializedTx);
+    if (txId !== '0x' + expectedTxId) {
+      throw new Error(`Expected ${expectedTxId}, core ${txId}`);
+    }
+    res
+      .set('Content-Type', 'text/html')
+      .send(
+        tokenTransferHtml +
+          '<h3>Broadcasted transaction:</h3>' +
+          `<a href="/extended/v1/tx/${txId}">${txId}</a>`
+      );
+  });
+
   const contractDeployHtml = `
     <style>
       * { font-family: "Lucida Console", Monaco, monospace; }
diff --git a/src/datastore/common.ts b/src/datastore/common.ts
index bfee0f554f..d21885f59e 100644
--- a/src/datastore/common.ts
+++ b/src/datastore/common.ts
@@ -145,6 +145,7 @@ export enum DbEventTypeId {
   StxAsset = 2,
   FungibleTokenAsset = 3,
   NonFungibleTokenAsset = 4,
+  StxLock = 5,
 }
 
 export interface DbEventBase {
@@ -163,6 +164,13 @@ export interface DbSmartContractEvent extends DbEventBase {
   value: Buffer;
 }
 
+export interface DbStxLockEvent extends DbEventBase {
+  event_type: DbEventTypeId.StxLock;
+  locked_amount: BigInt;
+  unlock_height: BigInt;
+  locked_address: string;
+}
+
 export enum DbAssetEventTypeId {
   Transfer = 1,
   Mint = 2,
@@ -196,7 +204,7 @@ export interface DbNftEvent extends DbContractAssetEvent {
   value: Buffer;
 }
 
-export type DbEvent = DbSmartContractEvent | DbStxEvent | DbFtEvent | DbNftEvent;
+export type DbEvent = DbSmartContractEvent | DbStxEvent | DbStxLockEvent | DbFtEvent | DbNftEvent;
 
 export interface AddressTxUpdateInfo {
   address: string;
@@ -217,6 +225,7 @@ export interface DataStoreUpdateData {
   txs: {
     tx: DbTx;
     stxEvents: DbStxEvent[];
+    stxLockEvents: DbStxLockEvent[];
     ftEvents: DbFtEvent[];
     nftEvents: DbNftEvent[];
     contractLogEvents: DbSmartContractEvent[];
diff --git a/src/datastore/memory-store.ts b/src/datastore/memory-store.ts
index d2896b9348..733d4f821a 100644
--- a/src/datastore/memory-store.ts
+++ b/src/datastore/memory-store.ts
@@ -16,6 +16,7 @@ import {
   DbMempoolTx,
   DbSearchResult,
   DbStxBalance,
+  DbStxLockEvent,
 } from './common';
 import { logger, FoundOrNot } from '../helpers';
 import { TransactionType } from '@blockstack/stacks-blockchain-api-types';
@@ -26,6 +27,10 @@ export class MemoryDataStore extends (EventEmitter as { new (): DataStoreEventEm
   readonly blocks: Map<string, { entry: DbBlock }> = new Map();
   readonly txs: Map<string, { entry: DbTx }> = new Map();
   readonly txMempool: Map<string, DbMempoolTx> = new Map();
+  readonly stxLockEvents: Map<
+    string,
+    { indexBlockHash: string; entry: DbStxLockEvent }
+  > = new Map();
   readonly stxTokenEvents: Map<string, { indexBlockHash: string; entry: DbStxEvent }> = new Map();
   readonly fungibleTokenEvents: Map<
     string,
@@ -49,6 +54,9 @@ export class MemoryDataStore extends (EventEmitter as { new (): DataStoreEventEm
     await this.updateBlock(data.block);
     for (const entry of data.txs) {
       await this.updateTx(entry.tx);
+      for (const stxLockEvent of entry.stxLockEvents) {
+        await this.updateStxLockEvent(entry.tx, stxLockEvent);
+      }
       for (const stxEvent of entry.stxEvents) {
         await this.updateStxEvent(entry.tx, stxEvent);
       }
@@ -90,6 +98,7 @@ export class MemoryDataStore extends (EventEmitter as { new (): DataStoreEventEm
         this.blocks,
         this.txs,
         this.smartContractEvents,
+        this.stxLockEvents,
         this.stxTokenEvents,
         this.fungibleTokenEvents,
         this.nonFungibleTokenEvents,
@@ -218,6 +227,9 @@ export class MemoryDataStore extends (EventEmitter as { new (): DataStoreEventEm
   }
 
   getTxEvents(txId: string, indexBlockHash: string) {
+    const stxLockEvents = [...this.stxLockEvents.values()].filter(
+      e => e.indexBlockHash === indexBlockHash && e.entry.tx_id === txId
+    );
     const stxEvents = [...this.stxTokenEvents.values()].filter(
       e => e.indexBlockHash === indexBlockHash && e.entry.tx_id === txId
     );
@@ -230,12 +242,26 @@ export class MemoryDataStore extends (EventEmitter as { new (): DataStoreEventEm
     const smartContractEvents = [...this.smartContractEvents.values()].filter(
       e => e.indexBlockHash === indexBlockHash && e.entry.tx_id === txId
     );
-    const allEvents = [...stxEvents, ...ftEvents, ...nftEvents, ...smartContractEvents]
+    const allEvents = [
+      ...stxLockEvents,
+      ...stxEvents,
+      ...ftEvents,
+      ...nftEvents,
+      ...smartContractEvents,
+    ]
       .sort(e => e.entry.event_index)
       .map(e => e.entry);
     return Promise.resolve({ results: allEvents });
   }
 
+  updateStxLockEvent(tx: DbTx, event: DbStxLockEvent) {
+    this.stxLockEvents.set(`${event.tx_id}_${tx.index_block_hash}_${event.event_index}`, {
+      indexBlockHash: tx.index_block_hash,
+      entry: { ...event },
+    });
+    return Promise.resolve();
+  }
+
   updateStxEvent(tx: DbTx, event: DbStxEvent) {
     this.stxTokenEvents.set(`${event.tx_id}_${tx.index_block_hash}_${event.event_index}`, {
       indexBlockHash: tx.index_block_hash,
diff --git a/src/datastore/postgres-store.ts b/src/datastore/postgres-store.ts
index 8d45ec0f79..759cb8c726 100644
--- a/src/datastore/postgres-store.ts
+++ b/src/datastore/postgres-store.ts
@@ -37,6 +37,7 @@ import {
   DbMempoolTxId,
   DbSearchResult,
   DbStxBalance,
+  DbStxLockEvent,
 } from './common';
 import { TransactionType } from '@blockstack/stacks-blockchain-api-types';
 import { getTxTypeId } from '../api/controllers/db-controller';
@@ -263,6 +264,7 @@ interface UpdatedEntities {
   markedCanonical: {
     blocks: number;
     txs: number;
+    stxLockEvents: number;
     stxEvents: number;
     ftEvents: number;
     nftEvents: number;
@@ -272,6 +274,7 @@ interface UpdatedEntities {
   markedNonCanonical: {
     blocks: number;
     txs: number;
+    stxLockEvents: number;
     stxEvents: number;
     ftEvents: number;
     nftEvents: number;
@@ -325,6 +328,7 @@ export class PgDataStore extends (EventEmitter as { new (): DataStoreEventEmitte
         data.block = { ...data.block, canonical: false };
         data.txs = data.txs.map(tx => ({
           tx: { ...tx.tx, canonical: false },
+          stxLockEvents: tx.stxLockEvents.map(e => ({ ...e, canonical: false })),
           stxEvents: tx.stxEvents.map(e => ({ ...e, canonical: false })),
           ftEvents: tx.ftEvents.map(e => ({ ...e, canonical: false })),
           nftEvents: tx.nftEvents.map(e => ({ ...e, canonical: false })),
@@ -346,6 +350,9 @@ export class PgDataStore extends (EventEmitter as { new (): DataStoreEventEmitte
       if (blocksUpdated !== 0) {
         for (const entry of data.txs) {
           await this.updateTx(client, entry.tx);
+          for (const stxLockEvent of entry.stxLockEvents) {
+            await this.updateStxLockEvent(client, entry.tx, stxLockEvent);
+          }
           for (const stxEvent of entry.stxEvents) {
             await this.updateStxEvent(client, entry.tx, stxEvent);
           }
@@ -390,6 +397,9 @@ export class PgDataStore extends (EventEmitter as { new (): DataStoreEventEmitte
         }
       };
       addAddressTx(tx.sender_address);
+      entry.stxLockEvents.forEach(event => {
+        addAddressTx(event.locked_address);
+      });
       entry.stxEvents.forEach(event => {
         addAddressTx(event.sender);
         addAddressTx(event.recipient);
@@ -470,6 +480,20 @@ export class PgDataStore extends (EventEmitter as { new (): DataStoreEventEmitte
       updatedEntities.markedNonCanonical.txs += txResult.rowCount;
     }
 
+    const stxLockResults = await client.query(
+      `
+      UPDATE stx_lock_events
+      SET canonical = $2
+      WHERE index_block_hash = $1 AND canonical != $2
+      `,
+      [indexBlockHash, canonical]
+    );
+    if (canonical) {
+      updatedEntities.markedCanonical.stxLockEvents += stxLockResults.rowCount;
+    } else {
+      updatedEntities.markedNonCanonical.stxLockEvents += stxLockResults.rowCount;
+    }
+
     const stxResults = await client.query(
       `
       UPDATE stx_events
@@ -638,6 +662,7 @@ export class PgDataStore extends (EventEmitter as { new (): DataStoreEventEmitte
       markedCanonical: {
         blocks: 0,
         txs: 0,
+        stxLockEvents: 0,
         stxEvents: 0,
         ftEvents: 0,
         nftEvents: 0,
@@ -647,6 +672,7 @@ export class PgDataStore extends (EventEmitter as { new (): DataStoreEventEmitte
       markedNonCanonical: {
         blocks: 0,
         txs: 0,
+        stxLockEvents: 0,
         stxEvents: 0,
         ftEvents: 0,
         nftEvents: 0,
@@ -702,6 +728,11 @@ export class PgDataStore extends (EventEmitter as { new (): DataStoreEventEmitte
     const updates = [
       ['blocks', updatedEntities.markedCanonical.blocks, updatedEntities.markedNonCanonical.blocks],
       ['txs', updatedEntities.markedCanonical.txs, updatedEntities.markedNonCanonical.txs],
+      [
+        'stx-lock events',
+        updatedEntities.markedCanonical.stxLockEvents,
+        updatedEntities.markedNonCanonical.stxLockEvents,
+      ],
       [
         'stx-token events',
         updatedEntities.markedCanonical.stxEvents,
@@ -1409,6 +1440,27 @@ export class PgDataStore extends (EventEmitter as { new (): DataStoreEventEmitte
     }
   }
 
+  async updateStxLockEvent(client: ClientBase, tx: DbTx, event: DbStxLockEvent) {
+    await client.query(
+      `
+      INSERT INTO stx_lock_events(
+        event_index, tx_id, tx_index, block_height, index_block_hash, canonical, locked_amount, unlock_height, locked_address
+      ) values($1, $2, $3, $4, $5, $6, $7, $8, $9)
+      `,
+      [
+        event.event_index,
+        hexToBuffer(event.tx_id),
+        event.tx_index,
+        event.block_height,
+        hexToBuffer(tx.index_block_hash),
+        event.canonical,
+        event.locked_amount,
+        event.unlock_height,
+        event.locked_address,
+      ]
+    );
+  }
+
   async updateStxEvent(client: ClientBase, tx: DbTx, event: DbStxEvent) {
     await client.query(
       `
diff --git a/src/event-stream/core-node-message.ts b/src/event-stream/core-node-message.ts
index 72dfd03867..e99c1a64c6 100644
--- a/src/event-stream/core-node-message.ts
+++ b/src/event-stream/core-node-message.ts
@@ -17,6 +17,7 @@ export enum CoreNodeEventType {
 export type NonStandardClarityValue = unknown;
 
 export interface CoreNodeEventBase {
+  /** 0x-prefix transaction hash. */
   txid: string;
 }
 
@@ -59,7 +60,14 @@ export interface StxBurnEvent extends CoreNodeEventBase {
 
 export interface StxLockEvent extends CoreNodeEventBase {
   type: CoreNodeEventType.StxLockEvent;
-  stx_lock_event: any;
+  /** TODO: what dis? */
+  committed: boolean;
+  stx_lock_event: {
+    /** String quoted base10 integer. */
+    locked_amount: string;
+    /** String quoted base10 integer. */
+    unlock_height: string;
+  };
 }
 
 export interface NftTransferEvent extends CoreNodeEventBase {
diff --git a/src/event-stream/event-server.ts b/src/event-stream/event-server.ts
index 03f667eecd..aa54d0ecb0 100644
--- a/src/event-stream/event-server.ts
+++ b/src/event-stream/event-server.ts
@@ -6,8 +6,8 @@ import * as bodyParser from 'body-parser';
 import { addAsync } from '@awaitjs/express';
 import PQueue from 'p-queue';
 
-import { hexToBuffer, logError, logger, digestSha512_256 } from '../helpers';
-import { CoreNodeMessage, CoreNodeEventType } from './core-node-message';
+import { hexToBuffer, logError, logger, digestSha512_256, assertNotNullish } from '../helpers';
+import { CoreNodeMessage, CoreNodeEventType, StxLockEvent } from './core-node-message';
 import {
   DataStore,
   createDbTxFromCoreMsg,
@@ -21,6 +21,7 @@ import {
   DbBlock,
   DataStoreUpdateData,
   createDbMempoolTxFromCoreMsg,
+  DbStxLockEvent,
 } from '../datastore/common';
 import { parseMessageTransactions, getTxSenderAddress, getTxSponsorAddress } from './reader';
 import { TransactionPayloadTypeID, readTransaction } from '../p2p/tx';
@@ -91,6 +92,7 @@ async function handleClientMessage(msg: CoreNodeMessage, db: DataStore): Promise
     dbData.txs[i] = {
       tx: createDbTxFromCoreMsg(tx),
       stxEvents: [],
+      stxLockEvents: [],
       ftEvents: [],
       nftEvents: [],
       contractLogEvents: [],
@@ -117,6 +119,7 @@ async function handleClientMessage(msg: CoreNodeMessage, db: DataStore): Promise
     // TODO: this is not a real event_index -- the core-node needs to keep track and return in better format.
     const eventIndex =
       dbTx.stxEvents.length +
+      dbTx.stxLockEvents.length +
       dbTx.ftEvents.length +
       dbTx.nftEvents.length +
       dbTx.contractLogEvents.length;
@@ -141,6 +144,22 @@ async function handleClientMessage(msg: CoreNodeMessage, db: DataStore): Promise
         dbTx.contractLogEvents.push(entry);
         break;
       }
+      case CoreNodeEventType.StxLockEvent: {
+        // TODO: THIS IS NOT SAFE. Core needs to add `locked_address` to the event payload.
+        const sender = assertNotNullish(
+          parsedMsg.parsed_transactions.find(t => t.core_tx.txid === event.txid),
+          () => `Failed to match StxLockEvent txid ${event.txid}`
+        ).sender_address;
+        const entry: DbStxLockEvent = {
+          ...dbEvent,
+          event_type: DbEventTypeId.StxLock,
+          locked_amount: BigInt(event.stx_lock_event.locked_amount),
+          unlock_height: BigInt(event.stx_lock_event.unlock_height),
+          locked_address: sender,
+        };
+        dbTx.stxLockEvents.push(entry);
+        break;
+      }
       case CoreNodeEventType.StxTransferEvent: {
         const entry: DbStxEvent = {
           ...dbEvent,
@@ -175,11 +194,6 @@ async function handleClientMessage(msg: CoreNodeMessage, db: DataStore): Promise
         dbTx.stxEvents.push(entry);
         break;
       }
-      case CoreNodeEventType.StxLockEvent: {
-        // TODO: implement stx lock event handler
-        logger.warn('stx lock event received but handler not yet implemented');
-        break;
-      }
       case CoreNodeEventType.FtTransferEvent: {
         const entry: DbFtEvent = {
           ...dbEvent,
diff --git a/src/migrations/1605100253938_stx_lock_events.ts b/src/migrations/1605100253938_stx_lock_events.ts
new file mode 100644
index 0000000000..fb95f29de8
--- /dev/null
+++ b/src/migrations/1605100253938_stx_lock_events.ts
@@ -0,0 +1,53 @@
+import { MigrationBuilder, ColumnDefinitions } from 'node-pg-migrate';
+
+export async function up(pgm: MigrationBuilder): Promise<void> {
+  pgm.createTable('stx_lock_events', {
+    id: {
+      type: 'serial',
+      primaryKey: true,
+    },
+    event_index: {
+      type: 'integer',
+      notNull: true,
+    },
+    tx_id: {
+      notNull: true,
+      type: 'bytea',
+    },
+    tx_index: {
+      type: 'smallint',
+      notNull: true,
+    },
+    block_height: {
+      type: 'integer',
+      notNull: true,
+    },
+    index_block_hash: {
+      type: 'bytea',
+      notNull: true,
+    },
+    canonical: {
+      type: 'boolean',
+      notNull: true,
+    },
+    locked_amount: {
+      type: 'numeric',
+      notNull: true,
+    },
+    unlock_height: {
+      type: 'bigint',
+      notNull: true,
+    },
+    locked_address: {
+      type: 'string',
+      notNull: true,
+    },
+  });
+
+  pgm.createIndex('stx_lock_events', 'tx_id');
+  pgm.createIndex('stx_lock_events', 'block_height');
+  pgm.createIndex('stx_lock_events', 'index_block_hash');
+  pgm.createIndex('stx_lock_events', 'canonical');
+  pgm.createIndex('stx_lock_events', 'locked_address');
+
+}
diff --git a/src/tests/api-tests.ts b/src/tests/api-tests.ts
index 226ea20ef1..474e465b10 100644
--- a/src/tests/api-tests.ts
+++ b/src/tests/api-tests.ts
@@ -1254,6 +1254,7 @@ describe('api tests', () => {
       txs: [
         {
           tx: tx1,
+          stxLockEvents: [],
           stxEvents: [],
           ftEvents: [],
           nftEvents: [],
@@ -1262,6 +1263,7 @@ describe('api tests', () => {
         },
         {
           tx: tx2,
+          stxLockEvents: [],
           stxEvents: [],
           ftEvents: [],
           nftEvents: [],
diff --git a/src/tests/datastore-tests.ts b/src/tests/datastore-tests.ts
index 1a76f18cbc..bb6e08c2fd 100644
--- a/src/tests/datastore-tests.ts
+++ b/src/tests/datastore-tests.ts
@@ -1622,6 +1622,7 @@ describe('postgres datastore', () => {
       txs: [
         {
           tx: tx1,
+          stxLockEvents: [],
           stxEvents: [stxEvent1],
           ftEvents: [ftEvent1],
           nftEvents: [nftEvent1],
@@ -1630,6 +1631,7 @@ describe('postgres datastore', () => {
         },
         {
           tx: tx2,
+          stxLockEvents: [],
           stxEvents: [],
           ftEvents: [],
           nftEvents: [],
@@ -1820,6 +1822,7 @@ describe('postgres datastore', () => {
       txs: [
         {
           tx: tx1,
+          stxLockEvents: [],
           stxEvents: [],
           ftEvents: [],
           nftEvents: [],
@@ -1880,6 +1883,7 @@ describe('postgres datastore', () => {
       txs: [
         {
           tx: tx1b,
+          stxLockEvents: [],
           stxEvents: [],
           ftEvents: [],
           nftEvents: [],
@@ -2030,6 +2034,7 @@ describe('postgres datastore', () => {
       markedCanonical: {
         blocks: 4,
         txs: 2,
+        stxLockEvents: 0,
         stxEvents: 0,
         ftEvents: 0,
         nftEvents: 0,
@@ -2039,6 +2044,7 @@ describe('postgres datastore', () => {
       markedNonCanonical: {
         blocks: 1,
         txs: 0,
+        stxLockEvents: 0,
         stxEvents: 0,
         ftEvents: 0,
         nftEvents: 0,
@@ -2143,6 +2149,7 @@ describe('postgres datastore', () => {
       txs: [
         {
           tx: tx1,
+          stxLockEvents: [],
           stxEvents: [],
           ftEvents: [],
           nftEvents: [],
@@ -2156,6 +2163,7 @@ describe('postgres datastore', () => {
       txs: [
         {
           tx: tx2,
+          stxLockEvents: [],
           stxEvents: [],
           ftEvents: [],
           nftEvents: [],
@@ -2211,6 +2219,7 @@ describe('postgres datastore', () => {
       txs: [
         {
           tx: tx3,
+          stxLockEvents: [],
           stxEvents: [],
           ftEvents: [],
           nftEvents: [],
diff --git a/src/tests/websocket-tests.ts b/src/tests/websocket-tests.ts
index 8d18e60e3a..96175b7f1b 100644
--- a/src/tests/websocket-tests.ts
+++ b/src/tests/websocket-tests.ts
@@ -104,6 +104,7 @@ describe('websocket notifications', () => {
       txs: [
         {
           tx,
+          stxLockEvents: [],
           stxEvents: [stxEvent],
           ftEvents: [],
           nftEvents: [],
@@ -235,6 +236,7 @@ describe('websocket notifications', () => {
       txs: [
         {
           tx,
+          stxLockEvents: [],
           stxEvents: [stxEvent],
           ftEvents: [],
           nftEvents: [],
@@ -353,6 +355,7 @@ describe('websocket notifications', () => {
       txs: [
         {
           tx,
+          stxLockEvents: [],
           stxEvents: [stxEvent],
           ftEvents: [],
           nftEvents: [],
@@ -465,6 +468,7 @@ describe('websocket notifications', () => {
       txs: [
         {
           tx,
+          stxLockEvents: [],
           stxEvents: [stxEvent],
           ftEvents: [],
           nftEvents: [],
@@ -560,6 +564,7 @@ describe('websocket notifications', () => {
       txs: [
         {
           tx,
+          stxLockEvents: [],
           stxEvents: [stxEvent],
           ftEvents: [],
           nftEvents: [],
diff --git a/tsconfig.json b/tsconfig.json
index 4045cba93a..b8e9df02ff 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -17,5 +17,5 @@
     }
   },
   "include": ["src/**/*"],
-  "exclude": ["lib", "src/@types/*"]
+  "exclude": ["lib", "src/@types/*", "node_modules"]
 }