@bsv/overlay 2.0.2 → 2.0.4

package/src/storage/knex/KnexStorage.ts

@@ -1,6 +1,21 @@
-import { Storage } from '../Storage.js'
+import {
+  Storage,
+  type AppliedTransaction,
+  type AppliedTransactionProofUpdate,
+  type StoredTransactionRecord,
+  type UnprovenAppliedTransactionCandidate
+} from '../Storage.js'
 import { Knex } from 'knex'
 import type { Output } from '../../Output.js'
+import { Transaction } from '@bsv/sdk'
+import {
+  BASM_ZERO_HASH,
+  type AdmittedTxRef,
+  type RawTransactionRecord,
+  type TopicAnchorTip,
+  type TopicBlockAnchor,
+  extractMerkleProofMetadata
+} from '../../BASM.js'
 
 const OUTPUT_SELECT_FIELDS = [
   'outputs.txid',
@@ -11,6 +26,7 @@ const OUTPUT_SELECT_FIELDS = [
   'outputs.outputsConsumed',
   'outputs.spent',
   'outputs.consumedBy',
+  'outputs.blockHeight',
   'outputs.score'
 ] as const
 
@@ -38,13 +54,46 @@ export class KnexStorage implements Storage {
     return {
       ...row,
       outputScript: Array.from(row.outputScript),
-      beef: includeBEEF ? (beefOverride ?? (row.beef !== undefined ? Array.from(row.beef) : undefined)) : undefined,
+      beef: (() => {
+        if (!includeBEEF) return undefined
+        if (beefOverride != null) return beefOverride
+        return row.beef != null ? Array.from(row.beef) : undefined
+      })(),
       spent: Boolean(row.spent),
       outputsConsumed: this.parseOutputRelations(row.outputsConsumed),
       consumedBy: this.parseOutputRelations(row.consumedBy)
     }
   }
 
+  private binaryToNumberArray(value: any): number[] | undefined {
+    if (value === undefined || value === null) {
+      return undefined
+    }
+    return Array.from(Buffer.from(value))
+  }
+
+  private binaryToHex(value: any): string | undefined {
+    const array = this.binaryToNumberArray(value)
+    if (array === undefined) {
+      return undefined
+    }
+    return Buffer.from(array).toString('hex')
+  }
+
+  private transactionRecordFromBEEF(txid: string, beef: number[]): StoredTransactionRecord {
+    const tx = Transaction.fromBEEF(beef)
+    const metadata = extractMerkleProofMetadata(txid, tx.merklePath)
+    return {
+      txid,
+      beef: tx.merklePath === undefined ? beef : tx.toAtomicBEEF(),
+      rawTx: Array.from(tx.toBinary()),
+      merklePath: tx.merklePath?.toBinary(),
+      blockHeight: metadata?.blockHeight,
+      blockIndex: metadata?.blockIndex,
+      merkleRoot: metadata?.merkleRoot
+    }
+  }
+
   private async fetchTransactionBeefMap(txids: string[]): Promise<Map<string, number[]>> {
     if (txids.length === 0) {
       return new Map<string, number[]>()
@@ -56,7 +105,7 @@ export class KnexStorage implements Storage {
 
     const beefByTxid = new Map<string, number[]>()
     for (const row of rows) {
-      if (row.beef !== undefined) {
+      if (row.beef !== undefined && row.beef !== null) {
         beefByTxid.set(row.txid, Array.from(row.beef))
       }
     }
@@ -179,10 +228,10 @@ export class KnexStorage implements Storage {
     return outputs.map(output => this.parseOutputRecord(output, true, beefByTxid.get(output.txid)))
   }
 
-  async deleteOutput (txid: string, outputIndex: number, _: string): Promise<void> {
+  async deleteOutput (txid: string, outputIndex: number, topic: string): Promise<void> {
     await this.knex.transaction(async trx => {
       // Delete the specific output
-      await trx('outputs').where({ txid, outputIndex }).del()
+      await trx('outputs').where({ txid, outputIndex, topic }).del()
 
       // Check how many outputs reference the same transaction
       const remainingOutputs = await trx('outputs').where({ txid }).count('* as count').first()
@@ -212,15 +261,27 @@ export class KnexStorage implements Storage {
           outputsConsumed: JSON.stringify(output.outputsConsumed),
           consumedBy: JSON.stringify(output.consumedBy),
           spent: output.spent,
-          score: output.score
+          score: output.score,
+          blockHeight: output.blockHeight
         })
       }
 
       if (output.beef !== undefined) {
-        await trx('transactions').insert({
+        const record = this.transactionRecordFromBEEF(output.txid, output.beef)
+        const transactionRecord: Record<string, any> = {
           txid: output.txid,
-          beef: Buffer.from(output.beef)
-        }).onConflict('txid').ignore()
+          updatedAt: new Date()
+        }
+        if (record.beef !== undefined) transactionRecord.beef = Buffer.from(record.beef)
+        if (record.rawTx !== undefined) transactionRecord.rawTx = Buffer.from(record.rawTx)
+        if (record.merklePath !== undefined) transactionRecord.merklePath = Buffer.from(record.merklePath)
+        if (record.blockHeight !== undefined) transactionRecord.blockHeight = record.blockHeight
+        if (record.blockIndex !== undefined) transactionRecord.blockIndex = record.blockIndex
+        if (record.merkleRoot !== undefined) transactionRecord.merkleRoot = record.merkleRoot
+
+        const mergeRecord = { ...transactionRecord }
+        delete mergeRecord.txid
+        await trx('transactions').insert(transactionRecord).onConflict('txid').merge(mergeRecord)
       }
     })
   }
@@ -242,9 +303,7 @@ export class KnexStorage implements Storage {
   }
 
   async updateTransactionBEEF (txid: string, beef: number[]): Promise<void> {
-    await this.knex('transactions').where({
-      txid
-    }).update('beef', Buffer.from(beef))
+    await this.upsertTransactionRecord(this.transactionRecordFromBEEF(txid, beef))
   }
 
   async updateOutputBlockHeight (txid: string, outputIndex: number, topic: string, blockHeight: number): Promise<void> {
@@ -255,10 +314,56 @@ export class KnexStorage implements Storage {
     }).update('blockHeight', blockHeight)
   }
 
-  async insertAppliedTransaction (tx: { txid: string, topic: string }): Promise<void> {
+  async upsertTransactionRecord(record: StoredTransactionRecord): Promise<void> {
+    const insert: Record<string, any> = {
+      txid: record.txid,
+      updatedAt: new Date()
+    }
+    if (record.beef !== undefined) insert.beef = Buffer.from(record.beef)
+    if (record.rawTx !== undefined) insert.rawTx = Buffer.from(record.rawTx)
+    if (record.merklePath !== undefined) insert.merklePath = Buffer.from(record.merklePath)
+    if (record.blockHeight !== undefined) insert.blockHeight = record.blockHeight
+    if (record.blockHash !== undefined) insert.blockHash = record.blockHash
+    if (record.blockIndex !== undefined) insert.blockIndex = record.blockIndex
+    if (record.merkleRoot !== undefined) insert.merkleRoot = record.merkleRoot
+
+    const merge = { ...insert }
+    delete merge.txid
+
+    await this.knex('transactions')
+      .insert(insert)
+      .onConflict('txid')
+      .merge(merge)
+  }
+
+  async updateAppliedTransactionProof(record: AppliedTransactionProofUpdate): Promise<void> {
+    await this.knex('applied_transactions')
+      .where({ txid: record.txid, topic: record.topic })
+      .update({
+        blockHeight: record.blockHeight,
+        blockHash: record.blockHash,
+        blockIndex: record.blockIndex,
+        merkleRoot: record.merkleRoot,
+        proven: true
+      })
+
+    if (record.blockHeight !== undefined) {
+      await this.knex('outputs')
+        .where({ txid: record.txid, topic: record.topic })
+        .update({ blockHeight: record.blockHeight })
+    }
+  }
+
+  async insertAppliedTransaction (tx: AppliedTransaction): Promise<void> {
     await this.knex('applied_transactions').insert({
       txid: tx.txid,
-      topic: tx.topic
+      topic: tx.topic,
+      blockHeight: tx.blockHeight,
+      blockHash: tx.blockHash,
+      blockIndex: tx.blockIndex,
+      merkleRoot: tx.merkleRoot,
+      firstSeenHeight: tx.firstSeenHeight,
+      proven: tx.proven ?? false
     })
   }
 
@@ -286,4 +391,261 @@ export class KnexStorage implements Storage {
 
     return result ? result.since : 0
   }
+
+  async findAdmittedTransactionsForBlock(topic: string, blockHeight: number, blockHash?: string): Promise<AdmittedTxRef[]> {
+    let query = this.knex('applied_transactions')
+      .where({ topic, blockHeight, proven: true })
+      .whereNotNull('blockIndex')
+
+    if (blockHash !== undefined) {
+      query = query.andWhere({ blockHash })
+    }
+
+    const rows = await query
+      .select(['txid', 'blockIndex'])
+      .orderBy('blockIndex', 'asc')
+
+    return rows.map(row => ({
+      txid: row.txid,
+      blockIndex: Number(row.blockIndex)
+    }))
+  }
+
+  async upsertTopicBlockAnchor(anchor: TopicBlockAnchor): Promise<void> {
+    await this.knex('topic_block_anchors')
+      .insert({
+        topic: anchor.topic,
+        blockHeight: anchor.blockHeight,
+        blockHash: anchor.blockHash,
+        basmRoot: anchor.basmRoot,
+        admittedCount: anchor.admittedCount,
+        tac: anchor.tac,
+        updatedAt: new Date()
+      })
+      .onConflict(['topic', 'blockHeight'])
+      .merge({
+        blockHash: anchor.blockHash,
+        basmRoot: anchor.basmRoot,
+        admittedCount: anchor.admittedCount,
+        tac: anchor.tac,
+        updatedAt: new Date()
+      })
+  }
+
+  async findTopicBlockAnchor(topic: string, blockHeight: number, blockHash?: string): Promise<TopicBlockAnchor | undefined> {
+    let query = this.knex('topic_block_anchors').where({ topic, blockHeight })
+    if (blockHash !== undefined) {
+      query = query.andWhere({ blockHash })
+    }
+    const row = await query.first()
+    if (row === undefined) {
+      return undefined
+    }
+    return {
+      topic: row.topic,
+      blockHeight: Number(row.blockHeight),
+      blockHash: row.blockHash,
+      basmRoot: row.basmRoot,
+      admittedCount: Number(row.admittedCount),
+      tac: row.tac
+    }
+  }
+
+  async findTopicBlockAnchors(topic: string, fromHeight: number, toHeight: number): Promise<TopicBlockAnchor[]> {
+    const rows = await this.knex('topic_block_anchors')
+      .where({ topic })
+      .andWhere('blockHeight', '>=', fromHeight)
+      .andWhere('blockHeight', '<=', toHeight)
+      .select(['topic', 'blockHeight', 'blockHash', 'basmRoot', 'admittedCount', 'tac'])
+      .orderBy('blockHeight', 'asc')
+
+    return rows.map(row => ({
+      topic: row.topic,
+      blockHeight: Number(row.blockHeight),
+      blockHash: row.blockHash,
+      basmRoot: row.basmRoot,
+      admittedCount: Number(row.admittedCount),
+      tac: row.tac
+    }))
+  }
+
+  async findTopicAnchorTip(topic: string): Promise<TopicAnchorTip | undefined> {
+    const row = await this.knex('topic_block_anchors')
+      .where({ topic })
+      .orderBy('blockHeight', 'desc')
+      .first()
+
+    if (row === undefined) {
+      return {
+        topic,
+        blockHeight: -1,
+        tac: BASM_ZERO_HASH
+      }
+    }
+
+    return {
+      topic: row.topic,
+      blockHeight: Number(row.blockHeight),
+      blockHash: row.blockHash,
+      basmRoot: row.basmRoot,
+      admittedCount: Number(row.admittedCount),
+      tac: row.tac
+    }
+  }
+
+  async findRawTransactions(txids: string[]): Promise<RawTransactionRecord[]> {
+    if (txids.length === 0) return []
+    const rows = await this.knex('transactions')
+      .whereIn('txid', txids)
+      .select(['txid', 'rawTx', 'beef'])
+
+    const records: RawTransactionRecord[] = []
+    for (const row of rows) {
+      let rawTx = this.binaryToHex(row.rawTx)
+      if (rawTx === undefined) {
+        const beef = this.binaryToNumberArray(row.beef)
+        if (beef !== undefined) {
+          rawTx = Transaction.fromBEEF(beef, row.txid).toHex()
+        }
+      }
+      if (rawTx !== undefined) {
+        records.push({ txid: row.txid, rawTx })
+      }
+    }
+    return records
+  }
+
+  async findTransactionMerklePaths(txids: string[]): Promise<Array<{
+    txid: string
+    merklePath: string
+    blockHeight?: number
+    blockHash?: string
+    blockIndex?: number
+    merkleRoot?: string
+  }>> {
+    if (txids.length === 0) return []
+    const rows = await this.knex('transactions')
+      .whereIn('txid', txids)
+      .select(['txid', 'merklePath', 'blockHeight', 'blockHash', 'blockIndex', 'merkleRoot', 'beef'])
+
+    const records: Array<{
+      txid: string
+      merklePath: string
+      blockHeight?: number
+      blockHash?: string
+      blockIndex?: number
+      merkleRoot?: string
+    }> = []
+
+    for (const row of rows) {
+      let merklePath = this.binaryToHex(row.merklePath)
+      if (merklePath === undefined) {
+        const beef = this.binaryToNumberArray(row.beef)
+        if (beef !== undefined) {
+          merklePath = Transaction.fromBEEF(beef, row.txid).merklePath?.toHex()
+        }
+      }
+      if (merklePath !== undefined) {
+        records.push({
+          txid: row.txid,
+          merklePath,
+          blockHeight: row.blockHeight === undefined || row.blockHeight === null ? undefined : Number(row.blockHeight),
+          blockHash: row.blockHash,
+          blockIndex: row.blockIndex === undefined || row.blockIndex === null ? undefined : Number(row.blockIndex),
+          merkleRoot: row.merkleRoot
+        })
+      }
+    }
+
+    return records
+  }
+
+  async findUnprovenAppliedTransactions(cutoffHeight: number, topic?: string): Promise<UnprovenAppliedTransactionCandidate[]> {
+    let query = this.knex('applied_transactions')
+      .where(builder => {
+        builder.where({ proven: false }).orWhereNull('proven')
+      })
+      .whereNotNull('firstSeenHeight')
+      .andWhere('firstSeenHeight', '<=', cutoffHeight)
+      .select(['txid', 'topic', 'firstSeenHeight'])
+
+    if (topic !== undefined) {
+      query = query.andWhere({ topic })
+    }
+
+    const rows = await query
+    const candidates: UnprovenAppliedTransactionCandidate[] = []
+
+    for (const row of rows) {
+      const outputs = await this.knex('outputs')
+        .where({ txid: row.txid, topic: row.topic })
+        .select(['txid', 'outputIndex'])
+
+      candidates.push({
+        txid: row.txid,
+        topic: row.topic,
+        firstSeenHeight: row.firstSeenHeight === undefined || row.firstSeenHeight === null ? undefined : Number(row.firstSeenHeight),
+        outputs: outputs.map(output => ({
+          txid: output.txid,
+          outputIndex: Number(output.outputIndex)
+        }))
+      })
+    }
+
+    return candidates
+  }
+
+  async deleteAppliedTransaction(txid: string, topic: string): Promise<void> {
+    await this.knex('applied_transactions').where({ txid, topic }).del()
+  }
+
+  async findProvenAppliedTransactionsByBlockHash(blockHash: string): Promise<Array<{ txid: string, topic: string, blockHeight: number }>> {
+    const rows = await this.knex('applied_transactions')
+      .where({ blockHash, proven: true })
+      .whereNotNull('blockHeight')
+      .select(['txid', 'topic', 'blockHeight'])
+
+    return rows.map(row => ({
+      txid: row.txid,
+      topic: row.topic,
+      blockHeight: Number(row.blockHeight)
+    }))
+  }
+
+  async findProvenAppliedTransactionsInRange(fromHeight: number, toHeight: number, topic?: string): Promise<Array<{ txid: string, topic: string, blockHeight: number, blockHash?: string, merkleRoot?: string }>> {
+    let query = this.knex('applied_transactions')
+      .where({ proven: true })
+      .andWhere('blockHeight', '>=', fromHeight)
+      .andWhere('blockHeight', '<=', toHeight)
+
+    if (topic !== undefined) {
+      query = query.andWhere({ topic })
+    }
+
+    const rows = await query.select(['txid', 'topic', 'blockHeight', 'blockHash', 'merkleRoot'])
+
+    return rows.map(row => ({
+      txid: row.txid,
+      topic: row.topic,
+      blockHeight: Number(row.blockHeight),
+      blockHash: row.blockHash ?? undefined,
+      merkleRoot: row.merkleRoot ?? undefined
+    }))
+  }
+
+  async demoteAppliedTransactionToUnproven(txid: string, topic: string): Promise<void> {
+    await this.knex('applied_transactions')
+      .where({ txid, topic })
+      .update({
+        blockHeight: null,
+        blockHash: null,
+        blockIndex: null,
+        merkleRoot: null,
+        proven: false
+      })
+
+    await this.knex('outputs')
+      .where({ txid, topic })
+      .update({ blockHeight: null })
+  }
 }

package/src/storage/knex/all-migrations.ts

@@ -7,6 +7,7 @@ import { up as enlargeUp, down as enlargeDown } from './migrations/2025-05-28-00
 import { up as gaspPaginationSupportUp, down as gaspPaginationSupportDown } from './migrations/2025-06-25-001-gasp-pagination-support.js'
 import { up as fixScoreColumnTypeUp, down as fixScoreColumnTypeDown } from './migrations/2025-07-22-001-fix-score-column-type.js'
 import { up as utxoLookupIndexUp, down as utxoLookupIndexDown } from './migrations/2025-11-11-001-utxo-lookup-index.js'
+import { up as brc136BasmUp, down as brc136BasmDown } from './migrations/2026-05-29-001-brc136-basm.js'
 
 /**
  * An array of all migrations, in order.
@@ -24,7 +25,8 @@ const allMigrations: Migration[] = [
   { up: enlargeUp, down: enlargeDown },
   { up: gaspPaginationSupportUp, down: gaspPaginationSupportDown },
   { up: fixScoreColumnTypeUp, down: fixScoreColumnTypeDown },
-  { up: utxoLookupIndexUp, down: utxoLookupIndexDown }
+  { up: utxoLookupIndexUp, down: utxoLookupIndexDown },
+  { up: brc136BasmUp, down: brc136BasmDown }
 ]
 
 export default allMigrations

package/src/storage/knex/migrations/2025-05-28-001-enlarge.ts

@@ -4,24 +4,16 @@ import type { Knex } from 'knex'
 export async function up (knex: Knex): Promise<void> {
   const client = (knex.client.config.client || '').toLowerCase()
 
-  /* ---------- outputs.outputScript ---------- */
   if (client.startsWith('mysql')) {
-    // MySQL / MariaDB – enlarge to LONGBLOB (4 GB)
     await knex.schema.alterTable('outputs', table => {
       table.specificType('outputScript', 'LONGBLOB').alter()
     })
   } else if (client === 'sqlite3') {
-    // SQLite – plain BLOB is already plenty, but run alter so Knex’s
-    // internal schema snapshot stays in sync.
     await knex.schema.alterTable('outputs', table => {
       table.binary('outputScript').alter()
     })
   }
 
-  /* ---------- transactions.beef ---------- */
-  // This column was already created as LONGBLOB in migration 3,
-  // but we enlarge defensively in case someone ran only the early
-  // migrations on a new database.
   if (client.startsWith('mysql')) {
     await knex.schema.alterTable('transactions', table => {
       table.specificType('beef', 'LONGBLOB').alter()
@@ -36,25 +28,13 @@ export async function up (knex: Knex): Promise<void> {
 export async function down (knex: Knex): Promise<void> {
   const client = (knex.client.config.client || '').toLowerCase()
 
-  /* ---------- outputs.outputScript ---------- */
-  if (client.startsWith('mysql')) {
-    // Revert to VARBINARY(255) – matches Knex’s default .binary()
-    await knex.schema.alterTable('outputs', table => {
-      table.binary('outputScript').alter()
-    })
-  } else if (client === 'sqlite3') {
-    // No-op (SQLite stores the whole blob either way)
+  if (client.startsWith('mysql') || client === 'sqlite3') {
     await knex.schema.alterTable('outputs', table => {
       table.binary('outputScript').alter()
     })
   }
 
-  /* ---------- transactions.beef ---------- */
-  if (client.startsWith('mysql')) {
-    await knex.schema.alterTable('transactions', table => {
-      table.binary('beef').alter()
-    })
-  } else if (client === 'sqlite3') {
+  if (client.startsWith('mysql') || client === 'sqlite3') {
     await knex.schema.alterTable('transactions', table => {
       table.binary('beef').alter()
     })

package/src/storage/knex/migrations/2026-05-29-001-brc136-basm.ts

@@ -0,0 +1,123 @@
+import type { Knex } from 'knex'
+
+function binaryLargeType(knex: Knex): string {
+  const client = String(knex.client.config.client ?? '').toLowerCase()
+  if (client.includes('mysql')) return 'longblob'
+  if (client.includes('pg')) return 'bytea'
+  return 'blob'
+}
+
+async function addColumnIfMissing(
+  knex: Knex,
+  tableName: string,
+  columnName: string,
+  addColumn: (table: Knex.TableBuilder) => void
+): Promise<void> {
+  const exists = await knex.schema.hasColumn(tableName, columnName)
+  if (!exists) {
+    await knex.schema.table(tableName, addColumn)
+  }
+}
+
+export async function up(knex: Knex): Promise<void> {
+  await addColumnIfMissing(knex, 'applied_transactions', 'blockHeight', table => {
+    table.integer('blockHeight').unsigned().nullable()
+  })
+  await addColumnIfMissing(knex, 'applied_transactions', 'blockHash', table => {
+    table.string('blockHash', 64).nullable()
+  })
+  await addColumnIfMissing(knex, 'applied_transactions', 'blockIndex', table => {
+    table.integer('blockIndex').unsigned().nullable()
+  })
+  await addColumnIfMissing(knex, 'applied_transactions', 'merkleRoot', table => {
+    table.string('merkleRoot', 64).nullable()
+  })
+  await addColumnIfMissing(knex, 'applied_transactions', 'firstSeenHeight', table => {
+    table.integer('firstSeenHeight').unsigned().nullable()
+  })
+  await addColumnIfMissing(knex, 'applied_transactions', 'proven', table => {
+    table.boolean('proven').notNullable().defaultTo(false)
+  })
+
+  await addColumnIfMissing(knex, 'transactions', 'rawTx', table => {
+    table.specificType('rawTx', binaryLargeType(knex)).nullable()
+  })
+  await addColumnIfMissing(knex, 'transactions', 'merklePath', table => {
+    table.specificType('merklePath', binaryLargeType(knex)).nullable()
+  })
+  await addColumnIfMissing(knex, 'transactions', 'blockHeight', table => {
+    table.integer('blockHeight').unsigned().nullable()
+  })
+  await addColumnIfMissing(knex, 'transactions', 'blockHash', table => {
+    table.string('blockHash', 64).nullable()
+  })
+  await addColumnIfMissing(knex, 'transactions', 'blockIndex', table => {
+    table.integer('blockIndex').unsigned().nullable()
+  })
+  await addColumnIfMissing(knex, 'transactions', 'merkleRoot', table => {
+    table.string('merkleRoot', 64).nullable()
+  })
+  await addColumnIfMissing(knex, 'transactions', 'updatedAt', table => {
+    table.timestamp('updatedAt').nullable()
+  })
+
+  const topicBlockAnchorsExists = await knex.schema.hasTable('topic_block_anchors')
+  if (!topicBlockAnchorsExists) {
+    await knex.schema.createTable('topic_block_anchors', table => {
+      table.increments()
+      table.string('topic').notNullable()
+      table.integer('blockHeight').unsigned().notNullable()
+      table.string('blockHash', 64).notNullable()
+      table.string('basmRoot', 64).notNullable()
+      table.integer('admittedCount').unsigned().notNullable()
+      table.string('tac', 64).notNullable()
+      table.timestamp('updatedAt').nullable()
+      table.unique(['topic', 'blockHeight'], 'idx_topic_block_anchors_topic_height_unique')
+      table.index(['topic', 'blockHeight'], 'idx_topic_block_anchors_topic_height')
+      table.index(['topic', 'blockHash'], 'idx_topic_block_anchors_topic_hash')
+    })
+  }
+
+  const syncStateExists = await knex.schema.hasTable('basm_sync_state')
+  if (!syncStateExists) {
+    await knex.schema.createTable('basm_sync_state', table => {
+      table.string('host').notNullable()
+      table.string('topic').notNullable()
+      table.integer('lastHeight').unsigned().notNullable().defaultTo(0)
+      table.timestamp('updatedAt').nullable()
+      table.primary(['host', 'topic'])
+      table.index('topic')
+    })
+  }
+
+  const appliedTopicHeightIndex = 'idx_applied_transactions_topic_height'
+  const hasAppliedTopicHeightIndex = await knex.schema.hasTable('applied_transactions')
+  if (hasAppliedTopicHeightIndex) {
+    await knex.schema.table('applied_transactions', table => {
+      table.index(['topic', 'blockHeight', 'blockHash', 'blockIndex'], appliedTopicHeightIndex)
+      table.index(['topic', 'proven', 'firstSeenHeight'], 'idx_applied_transactions_unproven')
+    })
+  }
+}
+
+export async function down(knex: Knex): Promise<void> {
+  await knex.schema.dropTableIfExists('basm_sync_state')
+  await knex.schema.dropTableIfExists('topic_block_anchors')
+
+  await knex.schema.table('applied_transactions', table => {
+    table.dropIndex(['topic', 'blockHeight', 'blockHash', 'blockIndex'], 'idx_applied_transactions_topic_height')
+    table.dropIndex(['topic', 'proven', 'firstSeenHeight'], 'idx_applied_transactions_unproven')
+  })
+
+  for (const column of ['updatedAt', 'merkleRoot', 'blockIndex', 'blockHash', 'blockHeight', 'merklePath', 'rawTx']) {
+    if (await knex.schema.hasColumn('transactions', column)) {
+      await knex.schema.table('transactions', table => table.dropColumn(column))
+    }
+  }
+
+  for (const column of ['proven', 'firstSeenHeight', 'merkleRoot', 'blockIndex', 'blockHash', 'blockHeight']) {
+    if (await knex.schema.hasColumn('applied_transactions', column)) {
+      await knex.schema.table('applied_transactions', table => table.dropColumn(column))
+    }
+  }
+}