@bsv/overlay 0.5.1 → 0.5.3

package/src/Engine.ts

@@ -151,44 +151,136 @@ export class Engine {
 
     const steak: STEAK = {}
     const dupeTopics = new Set<string>()
+    const failedTopics = new Set<string>()
+
+    // ===================================================================
+    // PHASE 1: VALIDATE (read-only, no mutations)
+    // ===================================================================
+    type TopicValidation = {
+      topic: string
+      isDupe: boolean
+      previousCoins: number[]
+      previousOutputs: Array<Output | null>
+      admissibleOutputs: AdmittanceInstructions
+    }
 
-    // Parallelize the topic processing
-    const topicPromises = taggedBEEF.topics.map(async topic => {
-      if (this.managers[topic] === undefined || this.managers[topic] === null) {
-        throw new Error(`This server does not support this topic: ${topic}`)
-      }
+    const topicValidations = taggedBEEF.topics.map(async (topic): Promise<TopicValidation> => {
+      try {
+        if (this.managers[topic] === undefined || this.managers[topic] === null) {
+          throw new Error(`This server does not support this topic: ${topic}`)
+        }
+
+        // Check for duplicate transactions
+        this.startTime(`dupCheck_${txid.substring(0, 10)}`)
+        const dupeCheck = await this.storage.doesAppliedTransactionExist({ txid, topic })
+        this.endTime(`dupCheck_${txid.substring(0, 10)}`)
+
+        if (dupeCheck) {
+          dupeTopics.add(topic)
+          return {
+            topic,
+            isDupe: true,
+            previousCoins: [],
+            previousOutputs: [],
+            admissibleOutputs: { outputsToAdmit: [], coinsToRetain: [] }
+          }
+        }
 
-      // Check for duplicate transactions
-      this.startTime(`dupCheck_${txid.substring(0, 10)}`)
-      const dupeCheck = await this.storage.doesAppliedTransactionExist({ txid, topic })
-      this.endTime(`dupCheck_${txid.substring(0, 10)}`)
+        // Identify previous coins admitted to this specific topic
+        const previousCoins: number[] = []
+        const outputPromises = tx.inputs.map(async (input, i) => {
+          const previousTXID = input.sourceTXID !== undefined ? input.sourceTXID : input.sourceTransaction?.id('hex')
+          if (previousTXID !== undefined) {
+            // Check if the previous output was admitted to this specific topic
+            const output = await this.storage.findOutput(previousTXID, input.sourceOutputIndex, topic)
+            if (output !== undefined && output !== null) {
+              previousCoins.push(i)
+              return output
+            }
+          }
+          return null
+        })
 
-      if (dupeCheck) {
-        dupeTopics.add(topic)
-        steak[topic] = { outputsToAdmit: [], coinsToRetain: [] }
-        return
+        this.startTime(`previousOutputQuery_${txid.substring(0, 10)}`)
+        const previousOutputs = await Promise.all(outputPromises)
+        this.endTime(`previousOutputQuery_${txid.substring(0, 10)}`)
+
+        // Determine which outputs are admissible for this topic (validation only)
+        this.startTime(`identifyAdmissibleOutputs_${txid.substring(0, 10)}`)
+        const admissibleOutputs = await this.managers[topic].identifyAdmissibleOutputs(
+          taggedBEEF.beef,
+          previousCoins,
+          offChainValues
+        )
+        this.endTime(`identifyAdmissibleOutputs_${txid.substring(0, 10)}`)
+
+        return {
+          topic,
+          isDupe: false,
+          previousCoins,
+          previousOutputs,
+          admissibleOutputs
+        }
+      } catch (error) {
+        this.logger.error('Error validating topic during submit:', error)
+        failedTopics.add(topic)
+        return {
+          topic,
+          isDupe: false,
+          previousCoins: [],
+          previousOutputs: [],
+          admissibleOutputs: { outputsToAdmit: [], coinsToRetain: [] }
+        }
       }
+    })
 
-      // Identify previous coins admitted to this specific topic
-      const previousCoins: number[] = []
-      const outputPromises = tx.inputs.map(async (input, i) => {
-        const previousTXID = input.sourceTXID !== undefined ? input.sourceTXID : input.sourceTransaction?.id('hex')
-        if (previousTXID !== undefined) {
-          // Check if the previous output was admitted to this specific topic
-          const output = await this.storage.findOutput(previousTXID, input.sourceOutputIndex, topic)
-          if (output !== undefined && output !== null) {
-            previousCoins.push(i)
-            return output
-          }
+    const validations = await Promise.all(topicValidations)
+
+    // Build preliminary STEAK from validation results
+    for (const validation of validations) {
+      steak[validation.topic] = validation.admissibleOutputs
+    }
+
+    // ===================================================================
+    // PHASE 2: BROADCAST (before any mutations)
+    // ===================================================================
+    this.startTime(`broadcast_${txid.substring(0, 10)}`)
+    if (mode !== 'historical-tx' && this.broadcaster !== undefined) {
+      try {
+        const response = await this.broadcaster.broadcast(tx)
+        if (isBroadcastFailure(response) && this.throwOnBroadcastFailure) {
+          const e = new Error(`Failed to broadcast transaction! Error: ${response.description}`)
+            ; (e as any).more = response.more
+          throw e
         }
-        return null
-      })
+      } catch (error) {
+        if (this.throwOnBroadcastFailure) {
+          throw error
+        }
+        this.logger.error('Error broadcasting transaction:', error)
+      }
+    }
+    this.endTime(`broadcast_${txid.substring(0, 10)}`)
 
-      this.startTime(`previousOutputQuery_${txid.substring(0, 10)}`)
-      const outputs = await Promise.all(outputPromises)
-      this.endTime(`previousOutputQuery_${txid.substring(0, 10)}`)
+    // Call the callback function with STEAK if it is provided (before storage mutations)
+    if (onSteakReady !== undefined) {
+      onSteakReady(steak)
+    }
+
+    // ===================================================================
+    // PHASE 3: MUTATE STORAGE (only after broadcast succeeded)
+    // ===================================================================
+    // Mark previous outputs as spent and notify lookup services
+    await Promise.all(validations.map(async (validation) => {
+      if (validation.isDupe || failedTopics.has(validation.topic)) {
+        return
+      }
 
-      const markSpentPromises = outputs.map(async (output) => {
+      const topic = validation.topic
+      const previousOutputs = validation.previousOutputs
+
+      // Mark all previous outputs as spent
+      const markSpentPromises = previousOutputs.map(async (output) => {
         if (output !== undefined && output !== null) {
           try {
             await this.storage.markUTXOAsSpent(output.txid, output.outputIndex, topic)
@@ -211,7 +303,7 @@ export class Engine {
                       }
                       return realSource === output.txid && i.sourceOutputIndex === output.outputIndex
                     })
-                    if (!inputIndex) {
+                    if (inputIndex === -1) {
                       throw new Error('Could not find input index')
                     }
                     await l.outputSpent({
@@ -253,173 +345,141 @@ export class Engine {
         }
       })
 
-      let admissibleOutputs: AdmittanceInstructions = { outputsToAdmit: [], coinsToRetain: [] }
-      // Determine which outputs are admissible for this topic
-      const admissibleOutputsPromise = (async () => {
-        try {
-          this.startTime(`identifyAdmissibleOutputs_${txid.substring(0, 10)}`)
-          admissibleOutputs = await this.managers[topic].identifyAdmissibleOutputs(taggedBEEF.beef, previousCoins, offChainValues)
-          this.endTime(`identifyAdmissibleOutputs_${txid.substring(0, 10)}`)
-        } catch (_) {
-          steak[topic] = { outputsToAdmit: [], coinsToRetain: [] }
-        }
-      })()
-
-      // Wait for both tasks to complete
-      await Promise.all([markSpentPromises, admissibleOutputsPromise])
-      // Keep track of what outputs were admitted for what topic
-      steak[topic] = admissibleOutputs
-    })
-
-    await Promise.all(topicPromises)
+      await Promise.all(markSpentPromises)
+    }))
 
-    // Broadcast the transaction if not historical and broadcaster is configured
-    this.startTime(`broadcast_${txid.substring(0, 10)}`)
-    if (mode !== 'historical-tx' && this.broadcaster !== undefined) {
-      const response = await this.broadcaster.broadcast(tx)
-      if (isBroadcastFailure(response) && this.throwOnBroadcastFailure) {
-        const e = new Error(`Failed to broadcast transaction! Error: ${response.description}`);
-        (e as any).more = response.more
-        throw e
-      }
-    }
-    this.endTime(`broadcast_${txid.substring(0, 10)}`)
-
-    // Call the callback function if it is provided (moved here to ensure topic processing is complete)
-    if (onSteakReady !== undefined) {
-      onSteakReady(steak)
-    }
-
-    // Update storage and notify lookup services
-    for (const topic of taggedBEEF.topics) {
+    // Continue with storage updates and lookup service notifications
+    for (const validation of validations) {
+      const topic = validation.topic
       if (dupeTopics.has(topic)) {
         continue
       }
-      // Keep track of which outputs to admit, mark as stale, or retain
-      const admissibleOutputs = steak[topic]
-      const outputsToAdmit: number[] = admissibleOutputs.outputsToAdmit
-      const outputsConsumed: Array<{
-        txid: string
-        outputIndex: number
-      }> = []
-
-      const outputsToMarkStale: Array<{
-        txid: string
-        previousOutputIndex: number
-        inputIndex: number
-      }> = []
-
-      // Recompute previousCoins for this topic to use in the update logic
-      const previousCoins: number[] = []
-      await Promise.all(tx.inputs.map(async (input, i) => {
-        const previousTXID = input.sourceTXID !== undefined ? input.sourceTXID : input.sourceTransaction?.id('hex')
-        if (previousTXID !== undefined) {
-          const output = await this.storage.findOutput(previousTXID, input.sourceOutputIndex, topic)
-          if (output !== undefined && output !== null) {
-            previousCoins.push(i)
-          }
-        }
-      }))
-
-      // For each of the previous UTXOs for this topic, if the UTXO was not included in the list of UTXOs identified for retention, then it will be marked as stale.
-      for (const inputIndex of previousCoins) {
-        const previousTXID = tx.inputs[inputIndex].sourceTXID ?? tx.inputs[inputIndex].sourceTransaction?.id('hex')
-        if (typeof previousTXID !== 'string') continue
-        const previousOutputIndex = tx.inputs[inputIndex].sourceOutputIndex
-        if (!admissibleOutputs.coinsToRetain.includes(inputIndex)) {
-          outputsToMarkStale.push({
-            txid: previousTXID,
-            previousOutputIndex,
-            inputIndex
-          })
-        } else {
-          outputsConsumed.push({
-            txid: previousTXID,
-            outputIndex: previousOutputIndex
-          })
-        }
+      if (failedTopics.has(topic)) {
+        continue
       }
-
-      // Remove stale outputs recursively
-      this.startTime(`lookForStaleOutputs_${txid.substring(0, 10)}`)
-      await Promise.all(outputsToMarkStale.map(async coin => {
-        const output = await this.storage.findOutput(coin.txid, coin.previousOutputIndex, topic)
-        if (output !== undefined && output !== null) {
-          await this.deleteUTXODeep(output)
-        }
-      }))
-      this.endTime(`lookForStaleOutputs_${txid.substring(0, 10)}`)
-
-      // Update the STEAK to indicate which coins were removed
-      steak[topic].coinsRemoved = outputsToMarkStale.map(x => x.inputIndex)
-
-      // Handle admittance and notification of incoming UTXOs
-      const newUTXOs: Array<{ txid: string, outputIndex: number }> = []
-      await Promise.all(outputsToAdmit.map(async outputIndex => {
-        if (typeof tx.outputs[outputIndex].satoshis !== 'number') return
-        this.startTime(`insertNewOutput_${txid.substring(0, 10)}`)
-        await this.storage.insertOutput({
-          txid,
-          outputIndex,
-          outputScript: tx.outputs[outputIndex].lockingScript.toBinary(),
-          satoshis: tx.outputs[outputIndex].satoshis,
-          topic,
-          spent: false,
-          beef: taggedBEEF.beef,
-          consumedBy: [],
-          outputsConsumed,
-          score: Date.now()
-        })
-        this.endTime(`insertNewOutput_${txid.substring(0, 10)}`)
-        newUTXOs.push({ txid, outputIndex })
-
-        this.startTime(`notifyLookupService${txid.substring(0, 10)}`)
-        await Promise.all(Object.values(this.lookupServices).map(async l => {
-          if (l.admissionMode === 'locking-script') {
-            if (
-              typeof tx.outputs[outputIndex].lockingScript !== 'object' ||
-              typeof tx.outputs[outputIndex].satoshis !== 'number'
-            ) {
-              return
-            }
-            await l.outputAdmittedByTopic({
-              mode: 'locking-script',
-              txid,
-              outputIndex,
-              lockingScript: tx.outputs[outputIndex].lockingScript,
-              satoshis: tx.outputs[outputIndex].satoshis,
-              topic,
-              offChainValues
+      try {
+        const admissibleOutputs = steak[topic]
+        const outputsToAdmit: number[] = admissibleOutputs.outputsToAdmit
+        const outputsConsumed: Array<{
+          txid: string
+          outputIndex: number
+        }> = []
+
+        const outputsToMarkStale: Array<{
+          txid: string
+          previousOutputIndex: number
+          inputIndex: number
+        }> = []
+
+        // Use previousCoins from validation
+        const previousCoins = validation.previousCoins
+
+        // For each of the previous UTXOs for this topic, if the UTXO was not included in the list of UTXOs identified for retention, then it will be marked as stale.
+        for (const inputIndex of previousCoins) {
+          const previousTXID = tx.inputs[inputIndex].sourceTXID ?? tx.inputs[inputIndex].sourceTransaction?.id('hex')
+          if (typeof previousTXID !== 'string') continue
+          const previousOutputIndex = tx.inputs[inputIndex].sourceOutputIndex
+          if (!admissibleOutputs.coinsToRetain.includes(inputIndex)) {
+            outputsToMarkStale.push({
+              txid: previousTXID,
+              previousOutputIndex,
+              inputIndex
             })
           } else {
-            await l.outputAdmittedByTopic({
-              mode: 'whole-tx',
-              atomicBEEF: tx.toAtomicBEEF(),
-              outputIndex,
-              topic,
-              offChainValues
+            outputsConsumed.push({
+              txid: previousTXID,
+              outputIndex: previousOutputIndex
             })
           }
-        }))
-        this.endTime(`notifyLookupService${txid.substring(0, 10)}`)
-      }))
-
-      this.startTime(`outputConsumed_${txid.substring(0, 10)}`)
-      // Update each output consumed to know who consumed it and insert applied transaction in parallel
-      await Promise.all([
-        ...outputsConsumed.map(async output => {
-          const outputToUpdate = await this.storage.findOutput(output.txid, output.outputIndex, topic)
-          if (outputToUpdate !== undefined && outputToUpdate !== null) {
-            const newConsumedBy = [...new Set([...newUTXOs, ...outputToUpdate.consumedBy])]
-            await this.storage.updateConsumedBy(output.txid, output.outputIndex, topic, newConsumedBy)
+        }
+
+        // Remove stale outputs recursively
+        this.startTime(`lookForStaleOutputs_${txid.substring(0, 10)}`)
+        await Promise.all(outputsToMarkStale.map(async coin => {
+          const output = await this.storage.findOutput(coin.txid, coin.previousOutputIndex, topic)
+          if (output !== undefined && output !== null) {
+            await this.deleteUTXODeep(output)
           }
-        }),
-        this.storage.insertAppliedTransaction({
-          txid,
-          topic
-        })
-      ])
-      this.endTime(`outputConsumed_${txid.substring(0, 10)}`)
+        }))
+        this.endTime(`lookForStaleOutputs_${txid.substring(0, 10)}`)
+
+        // Update the STEAK to indicate which coins were removed
+        steak[topic].coinsRemoved = outputsToMarkStale.map(x => x.inputIndex)
+
+        // Handle admittance and notification of incoming UTXOs
+        const newUTXOs: Array<{ txid: string, outputIndex: number }> = []
+        await Promise.all(outputsToAdmit.map(async outputIndex => {
+          if (typeof tx.outputs[outputIndex].satoshis !== 'number') return
+          this.startTime(`insertNewOutput_${txid.substring(0, 10)}`)
+          await this.storage.insertOutput({
+            txid,
+            outputIndex,
+            outputScript: tx.outputs[outputIndex].lockingScript.toBinary(),
+            satoshis: tx.outputs[outputIndex].satoshis,
+            topic,
+            spent: false,
+            beef: taggedBEEF.beef,
+            consumedBy: [],
+            outputsConsumed,
+            score: Date.now()
+          })
+          this.endTime(`insertNewOutput_${txid.substring(0, 10)}`)
+          newUTXOs.push({ txid, outputIndex })
+
+          this.startTime(`notifyLookupService${txid.substring(0, 10)}`)
+          await Promise.all(Object.values(this.lookupServices).map(async l => {
+            try {
+              if (l.admissionMode === 'locking-script') {
+                if (
+                  typeof tx.outputs[outputIndex].lockingScript !== 'object' ||
+                  typeof tx.outputs[outputIndex].satoshis !== 'number'
+                ) {
+                  return
+                }
+                await l.outputAdmittedByTopic({
+                  mode: 'locking-script',
+                  txid,
+                  outputIndex,
+                  lockingScript: tx.outputs[outputIndex].lockingScript,
+                  satoshis: tx.outputs[outputIndex].satoshis,
+                  topic,
+                  offChainValues
+                })
+              } else {
+                await l.outputAdmittedByTopic({
+                  mode: 'whole-tx',
+                  atomicBEEF: tx.toAtomicBEEF(),
+                  outputIndex,
+                  topic,
+                  offChainValues
+                })
+              }
+            } catch (error) {
+              this.logger.error('Error in lookup service for outputAdmittedByTopic:', error)
+            }
+          }))
+          this.endTime(`notifyLookupService${txid.substring(0, 10)}`)
+        }))
+
+        this.startTime(`outputConsumed_${txid.substring(0, 10)}`)
+        // Update each output consumed to know who consumed it and insert applied transaction in parallel
+        await Promise.all([
+          ...outputsConsumed.map(async output => {
+            const outputToUpdate = await this.storage.findOutput(output.txid, output.outputIndex, topic)
+            if (outputToUpdate !== undefined && outputToUpdate !== null) {
+              const newConsumedBy = [...new Set([...newUTXOs, ...outputToUpdate.consumedBy])]
+              await this.storage.updateConsumedBy(output.txid, output.outputIndex, topic, newConsumedBy)
+            }
+          }),
+          this.storage.insertAppliedTransaction({
+            txid,
+            topic
+          })
+        ])
+        this.endTime(`outputConsumed_${txid.substring(0, 10)}`)
+      } catch (error) {
+        this.logger.error('Error updating storage and notifying lookup services for topic', topic, error)
+      }
     }
 
     // If we don't have an advertiser or we are dealing with historical transactions, just return the steak

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

@@ -6,8 +6,7 @@ import { up as addedIndexesUp, down as addedIndexesDown } from './migrations/202
 import { up as enlargeUp, down as enlargeDown } from './migrations/2025-05-28-001-enlarge.js'
 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'
 
 /**
  * An array of all migrations, in order.
@@ -24,7 +23,8 @@ const allMigrations: Migration[] = [
   { up: addedIndexesUp, down: addedIndexesDown },
   { up: enlargeUp, down: enlargeDown },
   { up: gaspPaginationSupportUp, down: gaspPaginationSupportDown },
-  { up: fixScoreColumnTypeUp, down: fixScoreColumnTypeDown }
+  { up: fixScoreColumnTypeUp, down: fixScoreColumnTypeDown },
+  { up: utxoLookupIndexUp, down: utxoLookupIndexDown }
 ]
 
 export default allMigrations

package/src/storage/knex/migrations/2025-11-11-001-utxo-lookup-index.ts

@@ -0,0 +1,18 @@
+import type { Knex } from 'knex'
+
+/**
+ * Adds optimized index for findUTXOsForTopic queries.
+ * This query pattern is: WHERE topic = ? AND spent = false ORDER BY score
+ * The composite index (topic, spent, score) enables efficient range scans.
+ */
+export async function up (knex: Knex): Promise<void> {
+  await knex.schema.table('outputs', function (table) {
+    table.index(['topic', 'spent', 'score'], 'idx_outputs_topic_spent_score')
+  })
+}
+
+export async function down (knex: Knex): Promise<void> {
+  await knex.schema.table('outputs', function (table) {
+    table.dropIndex(['topic', 'spent', 'score'], 'idx_outputs_topic_spent_score')
+  })
+}

package/dist/cjs/src/AdmittanceInstructions.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=AdmittanceInstructions.js.map

package/dist/cjs/src/AdmittanceInstructions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AdmittanceInstructions.js","sourceRoot":"","sources":["../../../src/AdmittanceInstructions.ts"],"names":[],"mappings":""}

package/dist/cjs/src/LookupAnswer.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=LookupAnswer.js.map

package/dist/cjs/src/LookupAnswer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LookupAnswer.js","sourceRoot":"","sources":["../../../src/LookupAnswer.ts"],"names":[],"mappings":""}

package/dist/cjs/src/LookupQuestion.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=LookupQuestion.js.map

package/dist/cjs/src/LookupQuestion.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LookupQuestion.js","sourceRoot":"","sources":["../../../src/LookupQuestion.ts"],"names":[],"mappings":""}

package/dist/cjs/src/SHIPAdvertisement.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=SHIPAdvertisement.js.map

package/dist/cjs/src/SHIPAdvertisement.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SHIPAdvertisement.js","sourceRoot":"","sources":["../../../src/SHIPAdvertisement.ts"],"names":[],"mappings":""}

package/dist/cjs/src/SLAPAdvertisement.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=SLAPAdvertisement.js.map

package/dist/cjs/src/SLAPAdvertisement.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SLAPAdvertisement.js","sourceRoot":"","sources":["../../../src/SLAPAdvertisement.ts"],"names":[],"mappings":""}

package/dist/cjs/src/STEAK.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=STEAK.js.map

package/dist/cjs/src/STEAK.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"STEAK.js","sourceRoot":"","sources":["../../../src/STEAK.ts"],"names":[],"mappings":""}

package/dist/cjs/src/TaggedBEEF.js

@@ -1,3 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=TaggedBEEF.js.map

package/dist/cjs/src/TaggedBEEF.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"TaggedBEEF.js","sourceRoot":"","sources":["../../../src/TaggedBEEF.ts"],"names":[],"mappings":""}

package/dist/esm/src/AdmittanceInstructions.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=AdmittanceInstructions.js.map

package/dist/esm/src/AdmittanceInstructions.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AdmittanceInstructions.js","sourceRoot":"","sources":["../../../src/AdmittanceInstructions.ts"],"names":[],"mappings":""}

package/dist/esm/src/LookupAnswer.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=LookupAnswer.js.map

package/dist/esm/src/LookupAnswer.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LookupAnswer.js","sourceRoot":"","sources":["../../../src/LookupAnswer.ts"],"names":[],"mappings":""}

package/dist/esm/src/LookupQuestion.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=LookupQuestion.js.map

package/dist/esm/src/LookupQuestion.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"LookupQuestion.js","sourceRoot":"","sources":["../../../src/LookupQuestion.ts"],"names":[],"mappings":""}

package/dist/esm/src/SHIPAdvertisement.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=SHIPAdvertisement.js.map

package/dist/esm/src/SHIPAdvertisement.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SHIPAdvertisement.js","sourceRoot":"","sources":["../../../src/SHIPAdvertisement.ts"],"names":[],"mappings":""}

package/dist/esm/src/SLAPAdvertisement.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=SLAPAdvertisement.js.map

package/dist/esm/src/SLAPAdvertisement.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"SLAPAdvertisement.js","sourceRoot":"","sources":["../../../src/SLAPAdvertisement.ts"],"names":[],"mappings":""}

package/dist/esm/src/STEAK.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=STEAK.js.map

package/dist/esm/src/STEAK.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"STEAK.js","sourceRoot":"","sources":["../../../src/STEAK.ts"],"names":[],"mappings":""}

package/dist/esm/src/TaggedBEEF.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=TaggedBEEF.js.map

package/dist/esm/src/TaggedBEEF.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"TaggedBEEF.js","sourceRoot":"","sources":["../../../src/TaggedBEEF.ts"],"names":[],"mappings":""}

package/dist/types/src/AdmittanceInstructions.d.ts

@@ -1,14 +0,0 @@
-/**
- * Instructs the Overlay Services Engine about which outputs to admit and which previous outputs to retain. Returned by a Topic Manager.
- */
-export type AdmittanceInstructions = {
-    /**
-     * The indices of all admissable outputs into the managed topic from the provided transaction.
-     */
-    outputsToAdmit: number[];
-    /**
-     * The indices of all inputs from the provided transaction which spend previously-admitted outputs that should be retained for historical record-keeping.
-     */
-    coinsToRetain: number[];
-};
-//# sourceMappingURL=AdmittanceInstructions.d.ts.map