@bsv/overlay 2.2.1 → 2.3.0

package/src/GASP/OverlayGASPRemote.ts

@@ -1,108 +0,0 @@
-import { GASPInitialReply, GASPInitialRequest, GASPInitialResponse, GASPNode, GASPNodeResponse, GASPRemote } from '@bsv/gasp'
-
-export class OverlayGASPRemote implements GASPRemote {
-  constructor (public endpointURL: string, public topic: string) { }
-
-  /**
-   * Given an outgoing initial request, sends the request to the foreign instance and obtains their initial response.
-   * @param request
-   * @returns
-   */
-  async getInitialResponse (request: GASPInitialRequest): Promise<GASPInitialResponse> {
-    // Send out an HTTP request to the URL (current host for topic)
-    // Include the topic in the request
-    // Parse out response and return correct format
-    const url = `${this.endpointURL}/requestSyncResponse`
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'X-BSV-Topic': this.topic
-      },
-      body: JSON.stringify(request)
-    })
-
-    if (!response.ok) {
-      throw new Error(`HTTP error! Status: ${response.status}`)
-    }
-
-    const result: GASPInitialResponse = await response.json()
-
-    // Validate and return the response in the correct format
-    if (!Array.isArray(result.UTXOList) || typeof result.since !== 'number') {
-      throw new TypeError('Invalid response format')
-    }
-
-    return {
-      UTXOList: result.UTXOList.map((utxo: any) => ({
-        txid: utxo.txid,
-        outputIndex: utxo.outputIndex,
-        score: utxo.score ?? 0
-      })),
-      since: result.since
-    }
-  }
-
-  /**
-   * Given an outgoing txid, outputIndex and optional metadata, request the associated GASP node from the foreign instance.
-   * @param graphID
-   * @param txid
-   * @param outputIndex
-   * @param metadata
-   * @returns
-   */
-  async requestNode (graphID: string, txid: string, outputIndex: number, metadata: boolean): Promise<GASPNode> {
-    // Send an HTTP request with the provided info and get back a gaspNode
-    const url = `${this.endpointURL}/requestForeignGASPNode`
-    const body = {
-      graphID,
-      txid,
-      outputIndex,
-      metadata
-    }
-
-    const response = await fetch(url, {
-      method: 'POST',
-      headers: {
-        'Content-Type': 'application/json'
-      },
-      body: JSON.stringify(body)
-    })
-
-    if (!response.ok) {
-      throw new Error(`HTTP error! Status: ${response.status}`)
-    }
-
-    const result = await response.json()
-
-    // Validate and return the response in the correct format
-    if (typeof result.graphID !== 'string' || typeof result.rawTx !== 'string' || typeof result.outputIndex !== 'number') {
-      throw new TypeError('Invalid response format')
-    }
-
-    const gaspNode: GASPNode = {
-      graphID: result.graphID,
-      rawTx: result.rawTx,
-      outputIndex: result.outputIndex,
-      proof: result.proof,
-      txMetadata: result.txMetadata,
-      outputMetadata: result.outputMetadata,
-      inputs: result.inputs
-    }
-
-    return gaspNode
-  }
-
-  // ---- Now optional methods ----
-
-  // When are only syncing to them
-  async getInitialReply (response: GASPInitialResponse): Promise<GASPInitialReply> {
-    throw new Error('Function not supported!')
-  }
-
-  // Only used when supporting bidirectional sync.
-  // Overlay services does not support this.
-  async submitNode (node: GASPNode): Promise<GASPNodeResponse | undefined> {
-    throw new Error('Node submission not supported!')
-  }
-}

package/src/GASP/OverlayGASPStorage.ts

@@ -1,384 +0,0 @@
-import { GASPNode, GASPNodeResponse, GASPStorage, GASPOutput } from '@bsv/gasp'
-import { MerklePath, Transaction, Utils } from '@bsv/sdk'
-import { Engine } from '../Engine.js'
-
-/**
- * Represents a node in the temporary graph.
- */
-export interface GraphNode {
-  txid: string
-  graphID: string
-  rawTx: string
-  outputIndex: number
-  spentBy?: string
-  proof?: string
-  txMetadata?: string
-  outputMetadata?: string
-  inputs?: Record<string, { hash: string }>
-  children: GraphNode[]
-  parent?: GraphNode
-}
-
-export class OverlayGASPStorage implements GASPStorage {
-  readonly temporaryGraphNodeRefs: Record<string, GraphNode> = {}
-  private static activeAnchorValidations = 0
-  private static readonly anchorValidationQueue: Array<() => void> = []
-  private static activeFinalizations = 0
-  private static readonly finalizationQueue: Array<() => void> = []
-  private static readonly MAX_CONCURRENT_ANCHOR_VALIDATIONS = 4
-  private static readonly MAX_CONCURRENT_FINALIZATIONS = 2
-
-  constructor (public topic: string, public engine: Engine, public maxNodesInGraph?: number) { }
-
-  private static async acquireAnchorValidationSlot (): Promise<void> {
-    if (OverlayGASPStorage.activeAnchorValidations >= OverlayGASPStorage.MAX_CONCURRENT_ANCHOR_VALIDATIONS) {
-      await new Promise<void>(resolve => { OverlayGASPStorage.anchorValidationQueue.push(resolve) })
-    }
-    OverlayGASPStorage.activeAnchorValidations++
-  }
-
-  private static releaseAnchorValidationSlot (): void {
-    OverlayGASPStorage.activeAnchorValidations--
-    const next = OverlayGASPStorage.anchorValidationQueue.shift()
-    if (next !== undefined) {
-      next()
-    }
-  }
-
-  private static async acquireFinalizationSlot (): Promise<void> {
-    if (OverlayGASPStorage.activeFinalizations >= OverlayGASPStorage.MAX_CONCURRENT_FINALIZATIONS) {
-      await new Promise<void>(resolve => { OverlayGASPStorage.finalizationQueue.push(resolve) })
-    }
-    OverlayGASPStorage.activeFinalizations++
-  }
-
-  private static releaseFinalizationSlot (): void {
-    OverlayGASPStorage.activeFinalizations--
-    const next = OverlayGASPStorage.finalizationQueue.shift()
-    if (next !== undefined) {
-      next()
-    }
-  }
-
-  /**
-   *
-   * @param since
-   * @returns
-   */
-  async findKnownUTXOs (since: number): Promise<GASPOutput[]> {
-    const UTXOs = await this.engine.storage.findUTXOsForTopic(this.topic, since)
-    return UTXOs.map(output => ({
-      txid: output.txid,
-      outputIndex: output.outputIndex,
-      score: output.score ?? 0
-    }))
-  }
-
-  /**
-   * For a given txid and output index, returns the associated transaction, a merkle proof if the transaction is in a block, and metadata if if requested. If no metadata is requested, metadata hashes on inputs are not returned.
-   * @param graphID
-   * @param txid
-   * @param outputIndex
-   * @param metadata
-   * @returns
-   */
-  async hydrateGASPNode (graphID: string, txid: string, outputIndex: number, metadata: boolean): Promise<GASPNode> {
-    const output = await this.engine.storage.findOutput(txid, outputIndex, undefined, undefined, true)
-
-    if (output?.beef === undefined) {
-      throw new Error('No matching output found!')
-    }
-
-    const tx = Transaction.fromBEEF(output.beef)
-    const rawTx = tx.toHex()
-
-    const node: GASPNode = {
-      rawTx,
-      graphID,
-      outputIndex
-    }
-    if (tx.merklePath !== undefined) {
-      node.proof = tx.merklePath.toHex()
-    }
-
-    return node
-  }
-
-  /**
-  * For a given node, returns the inputs needed to complete the graph, including whether updated metadata is requested for those inputs.
-  * @param tx The node for which needed inputs should be found.
-  * @returns A promise for a mapping of requested input transactions and whether metadata should be provided for each.
-  */
-  async findNeededInputs (tx: GASPNode): Promise<GASPNodeResponse | undefined> {
-    // If there is no Merkle proof, we always need the inputs
-    const response: GASPNodeResponse = {
-      requestedInputs: {}
-    }
-    const parsedTx = Transaction.fromHex(tx.rawTx)
-    if (tx.proof === undefined) {
-      for (const input of parsedTx.inputs) {
-        response.requestedInputs[`${input.sourceTXID ?? ''}.${input.sourceOutputIndex}`] = {
-          metadata: false
-        }
-      }
-
-      return await this.stripAlreadyKnownInputs(response)
-    }
-
-    // Attempt to check if the current transaction is admissible
-    parsedTx.merklePath = MerklePath.fromHex(tx.proof)
-    const admittanceResult = await this.engine.managers[this.topic].identifyAdmissibleOutputs(
-      parsedTx.toBEEF(),
-      [],
-      typeof tx.txMetadata === 'string' ? Utils.toArray(tx.txMetadata) : undefined,
-      'historical-tx'
-    )
-    if (!admittanceResult.outputsToAdmit.includes(tx.outputIndex) && this.engine.managers[this.topic] !== undefined && typeof this.engine.managers[this.topic].identifyNeededInputs === 'function') {
-      // The transaction is not admissible, get inputs needed for further verification
-      // TopicManagers should implement a function to identify which inputs are needed.
-      try {
-        const neededInputs = await this.engine.managers[this.topic].identifyNeededInputs?.(parsedTx.toBEEF()) ?? []
-        for (const input of neededInputs) {
-          response.requestedInputs[`${input.txid}.${input.outputIndex}`] = {
-            metadata: false
-          }
-        }
-        return await this.stripAlreadyKnownInputs(response)
-      } catch (e) {
-        const message = e instanceof Error ? e.message : String(e)
-        console.error(`An error occurred when identifying needed inputs for transaction: ${parsedTx.id('hex')}.${tx.outputIndex}: ${message}`)
-        // Cut off the graph in case of an error here.
-      }
-      // By default, if the topic manager isn't able to stipulate needed inputs, only the inputs necessary for SPV are requested.
-    }
-    // Everything else falls through to returning undefined/void, which will terminate the synchronization at this point.
-  }
-
-  /**
-   * Ensures that no inputs are requested from foreign nodes before sending any GASP response
-   * Also terminates graphs if the response would be empty.
-   */
-  private async stripAlreadyKnownInputs (response: GASPNodeResponse | undefined): Promise<GASPNodeResponse | undefined> {
-    if (response === undefined) {
-      return response
-    }
-    for (const inputNodeId of Object.keys(response.requestedInputs)) {
-      const [txid, outputIndex] = inputNodeId.split('.')
-      const found = await this.engine.storage.findOutput(txid, Number(outputIndex), this.topic)
-      if (found !== null && found !== undefined) {
-        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-        delete response.requestedInputs[inputNodeId]
-      }
-    }
-    if (Object.keys(response.requestedInputs).length === 0) {
-      return undefined
-    }
-    return response
-  }
-
-  /**
-  * Appends a new node to a temporary graph.
-  * @param tx The node to append to this graph.
-  * @param spentBy Unless this is the same node identified by the graph ID, denotes the TXID and input index for the node which spent this one, in 36-byte format.
-  * @throws If the node cannot be appended to the graph, either because the graph ID is for a graph the recipient does not want or because the graph has grown to be too large before being finalized.
-  */
-  async appendToGraph (tx: GASPNode, spentBy?: string | undefined): Promise<void> {
-    if (this.maxNodesInGraph !== undefined && Object.keys(this.temporaryGraphNodeRefs).length >= this.maxNodesInGraph) {
-      throw new Error('The max number of nodes in transaction graph has been reached!')
-    }
-
-    const parsedTx = Transaction.fromHex(tx.rawTx)
-    const txid = parsedTx.id('hex')
-    if (tx.proof !== undefined) {
-      parsedTx.merklePath = MerklePath.fromHex(tx.proof)
-    }
-
-    // Given the passed in node, append to the temp graph
-    // Use the spentBy param which should be a txid.inputIndex for the node which spent this one in 36-byte format
-    const newGraphNode: GraphNode = {
-      txid,
-      graphID: tx.graphID,
-      rawTx: tx.rawTx,
-      outputIndex: tx.outputIndex,
-      proof: tx.proof,
-      txMetadata: tx.txMetadata,
-      outputMetadata: tx.outputMetadata,
-      inputs: tx.inputs,
-      children: []
-    }
-
-    // If spentBy is undefined, then we know it's the root node.
-    if (spentBy === undefined) {
-      this.temporaryGraphNodeRefs[tx.graphID] = newGraphNode
-    } else {
-      // Find the parent node based on spentBy
-      const parentNode = this.temporaryGraphNodeRefs[spentBy]
-
-      if (parentNode === undefined) {
-        throw new Error(`Parent node with GraphID ${spentBy} not found`)
-      }
-      // Set parent-child relationship
-      parentNode.children.push(newGraphNode)
-      newGraphNode.parent = parentNode
-      this.temporaryGraphNodeRefs[`${newGraphNode.txid}.${newGraphNode.outputIndex}`] = newGraphNode
-    }
-  }
-
-  /**
-    * Checks whether the given graph, in its current state, makes reference only to transactions that are proven in the blockchain, or already known by the recipient to be valid.
-    * Additionally, in a breadth-first manner (ensuring that all inputs for any given node are processed before nodes that spend them), it ensures that the root node remains valid according to the rules of the overlay's topic manager,
-    * while considering any coins which the Manager had previously indicated were either valid or invalid.
-    * @param graphID The TXID and output index (in 36-byte format) for the UTXO at the tip of this graph.
-    * @throws If the graph is not well-anchored, according to the rules of Bitcoin or the rules of the Overlay Topic Manager.
-    */
-  async validateGraphAnchor (graphID: string): Promise<void> {
-    await OverlayGASPStorage.acquireAnchorValidationSlot()
-    try {
-      const rootNode = this.temporaryGraphNodeRefs[graphID]
-      if (rootNode === undefined) {
-        throw new Error(`Graph node with ID ${graphID} not found`)
-      }
-
-      // Check that the root node is Bitcoin-valid.
-      const beef = this.getBEEFForNode(rootNode)
-      const spvTx = Transaction.fromBEEF(beef)
-      const isBitcoinValid = await spvTx.verify(this.engine.chainTracker)
-      if (!isBitcoinValid) {
-        throw new Error('The graph is not well-anchored according to the rules of Bitcoin.')
-      }
-
-      // Then, ensure the node is Overlay-valid.
-      const beefs = this.computeOrderedBEEFsForGraph(graphID)
-
-      // coins: a Set of all historical coins to retain (no need to remove them), used to emulate topical admittance of previous inputs over time.
-      const coins = new Set<string>()
-
-      // Submit all historical BEEFs in order through the topic manager, tracking what would be retained until we submit the root node last.
-      // If, at the end, the root node is admitted, we have a valid overlay-specific graph.
-      for (const beef of beefs) {
-        // For any input to this transaction, see if it's a valid coin that's admitted. If so, it's a previous coin.
-        const previousCoins: number[] = []
-        const tx = Transaction.fromBEEF(beef)
-        for (const [inputIndex, input] of tx.inputs.entries()) {
-          const sourceTXID = input.sourceTXID ?? input.sourceTransaction?.id('hex')
-          if (sourceTXID != null && sourceTXID !== '') {
-            const coin = `${sourceTXID}.${input.sourceOutputIndex}`
-            if (coins.has(coin)) {
-              previousCoins.push(Number(inputIndex))
-            }
-          }
-        }
-        const admittanceInstructions = await this.engine.managers[this.topic].identifyAdmissibleOutputs(
-          beef,
-          previousCoins,
-          undefined,
-          'historical-tx'
-        )
-        // Every admitted output is now a coin.
-        for (const outputIndex of admittanceInstructions.outputsToAdmit) {
-          coins.add(`${tx.id('hex')}.${outputIndex}`)
-        }
-      }
-      // After sending through all the graph's BEEFs...
-      // If the root node is now a coin, we have acceptance by the overlay.
-      // Otherwise, throw.
-      if (!coins.has(graphID)) {
-        throw new Error('This graph did not result in topical admittance of the root node. Rejecting.')
-      }
-    } finally {
-      OverlayGASPStorage.releaseAnchorValidationSlot()
-    }
-  }
-
-  /**
-   * Deletes all data associated with a temporary graph that has failed to sync, if the graph exists.
-   * @param graphID The TXID and output index (in 36-byte format) for the UTXO at the tip of this graph.
-   */
-  async discardGraph (graphID: string): Promise<void> {
-    for (const [nodeId, graphRef] of Object.entries(this.temporaryGraphNodeRefs)) {
-      if (graphRef.graphID === graphID) {
-        // Delete child node
-        // eslint-disable-next-line @typescript-eslint/no-dynamic-delete
-        delete this.temporaryGraphNodeRefs[nodeId]
-      }
-    }
-  }
-
-  /**
-   * Finalizes a graph, solidifying the new UTXO and its ancestors so that it will appear in the list of known UTXOs.
-   * @param graphID The TXID and output index (in 36-byte format) for the UTXO at the root of this graph.
-   */
-  async finalizeGraph (graphID: string): Promise<void> {
-    await OverlayGASPStorage.acquireFinalizationSlot()
-    try {
-      const beefs = this.computeOrderedBEEFsForGraph(graphID)
-
-      // Submit all historical BEEFs in order, finalizing the graph for the current UTXO.
-      // We skip SPV verification here because validateGraphAnchor has already done it.
-      for (const beef of beefs) {
-        await this.engine.submit({
-          beef,
-          topics: [this.topic]
-        }, () => { }, 'historical-tx-no-spv')
-      }
-    } finally {
-      OverlayGASPStorage.releaseFinalizationSlot()
-    }
-  }
-
-  /**
-   * Computes an ordered set of BEEFs for the graph with the given graph IDs
-   * @param {string} graphID — The ID of the graph for which BEEFs are required
-   * @returns Ordered BEEFs for the graph
-   */
-  private computeOrderedBEEFsForGraph (graphID: string): number[][] {
-    const beefs: number[][] = []
-    const hydrator = (node: GraphNode): void => {
-      const currentBEEF = this.getBEEFForNode(node)
-      if (!beefs.includes(currentBEEF)) {
-        beefs.unshift(currentBEEF)
-      }
-
-      for (const child of node.children) {
-        // Continue backwards to the earliest nodes, adding them onto the beginning
-        hydrator(child)
-      }
-    }
-
-    // Start the hydrator with the root node
-    const foundRoot = this.temporaryGraphNodeRefs[graphID]
-    if (foundRoot == null) {
-      throw new Error('Unable to find root node in graph for finalization!')
-    }
-    hydrator(foundRoot)
-    return beefs
-  }
-
-  /**
-   * Computes a full BEEF for a given graph node, based on the temporary graph store.
-   * @param node Graph node for which BEEF is needed.
-   * @returns BEEF array, including all proofs on inputs.
-   */
-  private getBEEFForNode (node: GraphNode): number[] {
-    // Given a node, hydrate its merkle proof or all inputs, returning a reference to the hydrated node's Transaction object
-    const hydrator = (node: GraphNode): Transaction => {
-      const tx = Transaction.fromHex(node.rawTx)
-      if (node.proof != null && node.proof !== '') {
-        tx.merklePath = MerklePath.fromHex(node.proof)
-        return tx // Transaction with proof, end of the line.
-      }
-      // For each input, look it up and recurse.
-      for (const [inputIndex, input] of tx.inputs.entries()) {
-        const foundNode = this.temporaryGraphNodeRefs[`${input.sourceTXID ?? ''}.${input.sourceOutputIndex}`]
-        if (foundNode == null) {
-          throw new Error('Required input node for unproven parent not found in temporary graph store. Ensure, for every parent of any given already-proven node (kept for Overlay-specific historical reasons), that a proof is also provided on those inputs. While implicitly they are valid by virtue of their descendents being proven in the blockchain, BEEF serialization will still fail when winding forward the topical UTXO set histories during sync.')
-        }
-        tx.inputs[inputIndex].sourceTransaction = hydrator(foundNode)
-      }
-      return tx
-    }
-
-    const finalTX = hydrator(node)
-    return finalTX.toBEEF()
-  }
-}

package/src/LookupFormula.ts

@@ -1,31 +0,0 @@
-/**
- * The formula that will be used by the Overlay Services Engine to compute the Lookup Answer. Can be returned by Lookup Services in response to a Lookup Question.
- */
-export type LookupFormula = Array<{
-  /**
-   * TXID of the transaction where an output responsive to the Lookup Question resides.
-   */
-  txid: string
-
-  /**
-   * Index of the transaction output responsive to the Lookup Question.
-   */
-  outputIndex: number
-
-  /**
-   * Decides what history to incorporate into the Lookup Answer.
-   *
-   * Optionally directs the Overlay Services Engine as to the historical context (preceding outputs) to include as part of the Lookup Answer.
-   * - If a number, denotes how many previous spends (in terms of chain depth) the Engine should include with the Answer.
-   * - If a decider function, accepts a BEEF-formatted transaction, an output index and the current depth (relative to the top-level responsive UTXO) as parameters.
-   *   The function returns a promise for a boolean indicating whether the output should be incorporated into the Lookup Answer.
-   *   If so, the function will be called again for transactions that preceded the one provided, ultimately allowing the complete shape of the responsive spend history to be described.
-   * If not provided, no historical information will be included with the Lookup Answer, except that which may incidentally be required to fully anchor the Lookup Answer to the blockchain.
-   */
-  history?: ((beef: number[], outputIndex: number, currentDepth: number) => Promise<boolean>) | number
-
-  /**
-   * Context for the UTXO, derived from the off-chain values.
-   */
-  context?: number[]
-}>

package/src/LookupService.ts

@@ -1,136 +0,0 @@
-import { LookupFormula } from './LookupFormula.js'
-import { Script, LookupQuestion } from '@bsv/sdk'
-
-
-/* ---------------------------------------------------------------------------
- *  Modes a Lookup Service may request from the Overlay Services Engine
- * -------------------------------------------------------------------------- */
-export type AdmissionMode = 'locking-script' | 'whole-tx'
-export type SpendNotificationMode = 'none' | 'txid' | 'script' | 'whole-tx'
-
-/* ---------------------------------------------------------------------------
- *  Admission-Notification payloads
- * -------------------------------------------------------------------------- */
-export type OutputAdmittedByTopic =
-  | { // «locking-script» mode
-    mode: 'locking-script'
-    txid: string // ID of the *admitted* transaction
-    outputIndex: number // index of admitted output
-    topic: string // topic into which it was admitted
-    satoshis: number // value of the output
-    lockingScript: Script // script in this output
-    offChainValues?: number[] // off-chain values associated with the output
-  }
-  | { // «whole-tx» mode
-    mode: 'whole-tx'
-    atomicBEEF: number[] // whole transaction (Atomic BEEF)
-    outputIndex: number
-    topic: string
-    offChainValues?: number[]
-  }
-
-/* ---------------------------------------------------------------------------
- *  Spend-Notification payloads
- * -------------------------------------------------------------------------- */
-export type OutputSpent =
-  | { // «none»      – “it was spent”
-    mode: 'none'
-    txid: string
-    outputIndex: number
-    topic: string
-  }
-  | { // «txid»      – pointer only
-    mode: 'txid'
-    txid: string
-    outputIndex: number
-    topic: string
-    spendingTxid: string
-  }
-  | { // «script»    – granular input data
-    mode: 'script'
-    txid: string
-    outputIndex: number
-    topic: string
-    spendingTxid: string
-    inputIndex: number
-    unlockingScript: Script
-    sequenceNumber: number
-    offChainValues?: number[]
-  }
-  | { // «whole-tx»  – full spending TX
-    mode: 'whole-tx'
-    txid: string
-    outputIndex: number
-    topic: string
-    spendingAtomicBEEF: number[]
-    offChainValues?: number[]
-  }
-
-/* ---------------------------------------------------------------------------
- *  Metadata structure returned by getMetaData()
- * -------------------------------------------------------------------------- */
-export interface LookupServiceMetaData {
-  name: string
-  shortDescription: string
-  iconURL?: string
-  version?: string
-  informationURL?: string
-}
-
-/* ---------------------------------------------------------------------------
- *  Lookup Service Interface
- * -------------------------------------------------------------------------- */
-export interface LookupService {
-  /* -------------------------------------------------------------------------
-   *  REQUIRED static declarations
-   * ----------------------------------------------------------------------- */
-  readonly admissionMode: AdmissionMode
-  readonly spendNotificationMode: SpendNotificationMode
-
-  /* -------------------------------------------------------------------------
-   *  REQUIRED lifecycle hooks
-   * ----------------------------------------------------------------------- */
-  /**
-   * Invoked when a Topic Manager admits a new UTXO.
-   * The payload shape depends on this.admissionMode.
-   */
-  outputAdmittedByTopic: (payload: OutputAdmittedByTopic) => Promise<void> | void
-
-  /**
-   * Invoked when a previously-admitted UTXO is spent.
-   * The payload shape depends on this.spendNotificationMode.
-   */
-  outputSpent?: (payload: OutputSpent) => Promise<void> | void
-
-  /**
-   * Called when a Topic Manager decides that **historical retention** of the
-   * specified UTXO is no longer required.
-   */
-  outputNoLongerRetainedInHistory?: (
-    txid: string,
-    outputIndex: number,
-    topic: string
-  ) => Promise<void> | void
-
-  /**
-   * LEGAL EVICTION:
-   * Permanently remove the referenced UTXO from all indices maintained by the
-   * Lookup Service.  After eviction the service MUST NOT reference the output
-   * in any future lookup answer.
-   */
-  outputEvicted: (
-    txid: string,
-    outputIndex: number
-  ) => Promise<void> | void
-
-  /* -------------------------------------------------------------------------
-   *  Query API
-   * ----------------------------------------------------------------------- */
-  lookup: (question: LookupQuestion) => Promise<LookupFormula>
-
-  /* -------------------------------------------------------------------------
-   *  Documentation helpers
-   * ----------------------------------------------------------------------- */
-  getDocumentation: () => Promise<string>
-  getMetaData: () => Promise<LookupServiceMetaData>
-}

package/src/Output.ts

@@ -1,31 +0,0 @@
-/**
- * Represents an output to be tracked by the Overlay Services Engine
- */
-export interface Output {
-  /** TXID of the output */
-  txid: string
-  /** index of the output */
-  outputIndex: number
-  /** script of the output */
-  outputScript: number[]
-  /** number of satoshis in the output */
-  satoshis: number
-  /** topic to which the output belongs */
-  topic: string
-  /** Whether the output is spent */
-  spent: boolean
-  /** Outputs consumed by the transaction associated with the output */
-  outputsConsumed: Array<{
-    txid: string
-    outputIndex: number
-  }>
-  /** Outputs consuming this output */
-  consumedBy: Array<{
-    txid: string
-    outputIndex: number
-  }>
-  /** The transaction data for the output */
-  beef?: number[]
-  blockHeight?: number
-  score?: number 
-}