@bsv/overlay 0.5.4 → 0.6.1

package/src/TopicManager.ts

@@ -9,7 +9,12 @@ export interface TopicManager {
    * Accepts the transaction in BEEF format and an array of those input indices which spend previously-admitted outputs from the same topic.
    * The transaction's BEEF structure will always contain the transactions associated with previous coins for reference (if any), regardless of whether the current transaction was directly proven.
    */
-  identifyAdmissibleOutputs: (beef: number[], previousCoins: number[], offChainValues?: number[]) => Promise<AdmittanceInstructions>
+  identifyAdmissibleOutputs: (
+    beef: number[],
+    previousCoins: number[],
+    offChainValues?: number[],
+    mode?: 'historical-tx' | 'current-tx' | 'historical-tx-no-spv'
+  ) => Promise<AdmittanceInstructions>
 
   /**
    * Identifies and returns the inputs needed to anchor any topical outputs from this transaction to their associated previous history.

package/src/__tests/Engine.test.ts

@@ -528,12 +528,16 @@ describe('BSV Overlay Services Engine', () => {
           mockChainTracker
         )
 
-        // Submit the utxo
         await engine.submit({
           beef: exampleBeef,
           topics: ['Hello']
         })
-        expect(engine.managers.Hello.identifyAdmissibleOutputs).toHaveBeenCalledWith(exampleBeef, [0], undefined)
+        expect(engine.managers.Hello.identifyAdmissibleOutputs).toHaveBeenCalledWith(
+          exampleBeef,
+          [0],
+          undefined,
+          'current-tx'
+        )
       })
       describe('When previous UTXOs were retained by the topic manager', () => {
         it('Notifies all lookup services about the output being spent (not deleted, see the comment about this in deleteUTXODeep)', async () => {

package/src/storage/knex/KnexStorage.ts

@@ -170,28 +170,33 @@ export class KnexStorage implements Storage {
   }
 
   async insertOutput (output: Output): Promise<void> {
-    const insertPromises = [this.knex('outputs').insert({
-      txid: output.txid,
-      outputIndex: Number(output.outputIndex),
-      outputScript: Buffer.from(output.outputScript),
-      topic: output.topic,
-      satoshis: Number(output.satoshis),
-      outputsConsumed: JSON.stringify(output.outputsConsumed),
-      consumedBy: JSON.stringify(output.consumedBy),
-      spent: output.spent,
-      score: output.score
-    })]
-
-    if (output.beef !== undefined) {
-      const insertTransactionPromise = this.knex('transactions').insert({
+    await this.knex.transaction(async trx => {
+      const existing = await trx('outputs').where({
         txid: output.txid,
-        beef: Buffer.from(output.beef)
-      }).onConflict('txid').ignore()
-      insertPromises.push(insertTransactionPromise)
-    }
+        outputIndex: Number(output.outputIndex),
+        topic: output.topic
+      }).first()
+
+      if (existing === undefined || existing === null) {
+        await trx('outputs').insert({
+          txid: output.txid,
+          outputIndex: Number(output.outputIndex),
+          outputScript: Buffer.from(output.outputScript),
+          topic: output.topic,
+          satoshis: Number(output.satoshis),
+          outputsConsumed: JSON.stringify(output.outputsConsumed),
+          consumedBy: JSON.stringify(output.consumedBy),
+          spent: output.spent,
+          score: output.score
+        })
+      }
 
-    await this.knex.transaction(async trx => {
-      await Promise.all(insertPromises.map(promise => promise.transacting(trx)))
+      if (output.beef !== undefined) {
+        await trx('transactions').insert({
+          txid: output.txid,
+          beef: Buffer.from(output.beef)
+        }).onConflict('txid').ignore()
+      }
     })
   }