feat(BUX-168, BUX-172): BEEF v2 (unmined inputs) + complex SPV

action_transaction.go

@@ -35,122 +35,24 @@ func (c *Client) RecordTransaction(ctx context.Context, xPubKey, txHex, draftID
 	return recordTransaction(ctx, c, rts, opts...)
 }
 
-// RecordRawTransaction will parse the transaction and save it into the Datastore directly, without any checks
-//
+// RecordRawTransaction will parse the transaction and save it into the Datastore directly, without any checks or broadcast but bux will ask network for information if transaction was mined
+// The transaction is treat as external incoming transaction - transaction without a draft
 // Only use this function when you know what you are doing!
 //
 // txHex is the raw transaction hex
 // opts are model options and can include "metadata"
 func (c *Client) RecordRawTransaction(ctx context.Context, txHex string,
 	opts ...ModelOps,
 ) (*Transaction, error) {
-	// Check for existing NewRelic transaction
 	ctx = c.GetOrStartTxn(ctx, "record_raw_transaction")
 
-	return c.recordTxHex(ctx, txHex, opts...)
-}
-
-// RecordMonitoredTransaction will parse the transaction and save it into the Datastore
-//
-// This function will try to record the transaction directly, without checking draft ids etc.
-//
-//nolint:nolintlint,unparam,gci // opts is the way, but not yet being used
-func recordMonitoredTransaction(ctx context.Context, client ClientInterface, txHex string,
-	opts ...ModelOps,
-) (*Transaction, error) {
-	// Check for existing NewRelic transaction
-	ctx = client.GetOrStartTxn(ctx, "record_monitored_transaction")
-
-	transaction, err := client.recordTxHex(ctx, txHex, opts...)
-	if err != nil {
-		return nil, err
-	}
-
-	if transaction.BlockHash == "" {
-		// Create the sync transaction model
-		sync := newSyncTransaction(
-			transaction.GetID(),
-			transaction.Client().DefaultSyncConfig(),
-			transaction.GetOptions(true)...,
-		)
-		sync.BroadcastStatus = SyncStatusSkipped
-		sync.P2PStatus = SyncStatusSkipped
-
-		// Use the same metadata
-		sync.Metadata = transaction.Metadata
-
-		// If all the options are skipped, do not make a new model (ignore the record)
-		if !sync.isSkipped() {
-			if err = sync.Save(ctx); err != nil {
-				return nil, err
-			}
-		}
-	}
-
-	return transaction, nil
-}
-
-func (c *Client) recordTxHex(ctx context.Context, txHex string, opts ...ModelOps) (*Transaction, error) {
-	// Create the model & set the default options (gives options from client->model)
-	newOpts := c.DefaultModelOptions(append(opts, New())...)
-	transaction := newTransaction(txHex, newOpts...)
-
-	// Ensure that we have a transaction id (created from the txHex)
-	id := transaction.GetID()
-	if len(id) == 0 {
-		return nil, ErrMissingTxHex
-	}
-
-	// Create the lock and set the release for after the function completes
-	unlock, err := newWriteLock(
-		ctx, fmt.Sprintf(lockKeyRecordTx, id), c.Cachestore(),
-	)
-	defer unlock()
-	if err != nil {
-		return nil, err
-	}
-
-	// Logic moved from BeforeCreating hook - should be refactorized in next iteration
-
-	// If we are external and the user disabled incoming transaction checking, check outputs
-	if transaction.isExternal() && !transaction.Client().IsITCEnabled() {
-		// Check that the transaction has >= 1 known destination
-		if !transaction.TransactionBase.hasOneKnownDestination(ctx, transaction.Client(), transaction.GetOptions(false)...) {
-			return nil, ErrNoMatchingOutputs
-		}
-	}
-
-	// Process the UTXOs
-	if err = transaction.processUtxos(ctx); err != nil {
-		return nil, err
-	}
-
-	// Set the values from the inputs/outputs and draft tx
-	transaction.TotalValue, transaction.Fee = transaction.getValues()
-
-	// Add values
-	transaction.NumberOfInputs = uint32(len(transaction.TransactionBase.parsedTx.Inputs))
-	transaction.NumberOfOutputs = uint32(len(transaction.TransactionBase.parsedTx.Outputs))
-
-	// /Logic moved from BeforeCreating hook - should be refactorized in next iteration
-
+	allowUnknown := true
 	monitor := c.options.chainstate.Monitor()
-
 	if monitor != nil {
-		// do not register transactions we have nothing to do with
-		allowUnknown := monitor.AllowUnknownTransactions()
-		if transaction.XpubInIDs == nil && transaction.XpubOutIDs == nil && !allowUnknown {
-			return nil, ErrTransactionUnknown
-		}
+		allowUnknown = monitor.AllowUnknownTransactions()
 	}
 
-	// save the transaction model
-	if err = transaction.Save(ctx); err != nil {
-		return nil, err
-	}
-
-	// Return the response
-	return transaction, nil
+	return saveRawTransaction(ctx, c, allowUnknown, txHex, opts...)
 }
 
 // NewTransaction will create a new draft transaction and return it
@@ -218,6 +120,25 @@ func (c *Client) GetTransactionByID(ctx context.Context, txID string) (*Transact
 	return c.GetTransaction(ctx, "", txID)
 }
 
+func (c *Client) GetTransactionsByIDs(ctx context.Context, txIDs []string) ([]*Transaction, error) {
+	// Check for existing NewRelic transaction
+	ctx = c.GetOrStartTxn(ctx, "get_transactions_by_ids")
+
+	// Create the conditions
+	conditions := generateTxIdFilterConditions(txIDs)
+
+	// Get the transactions by it's IDs
+	transactions, err := getTransactions(
+		ctx, nil, conditions, nil,
+		c.DefaultModelOptions()...,
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return transactions, nil
+}
+
 // GetTransactionByHex will get a transaction from the Datastore by its full hex string
 // uses GetTransaction
 func (c *Client) GetTransactionByHex(ctx context.Context, hex string) (*Transaction, error) {
@@ -492,3 +413,17 @@ func (c *Client) RevertTransaction(ctx context.Context, id string) error {
 
 	return err
 }
+
+func generateTxIdFilterConditions(txIDs []string) *map[string]interface{} {
+	orConditions := make([]map[string]interface{}, len(txIDs))
+
+	for i, txID := range txIDs {
+		orConditions[i] = map[string]interface{}{"id": txID}
+	}
+
+	conditions := &map[string]interface{}{
+		"$or": orConditions,
+	}
+
+	return conditions
+}

action_transaction_test.go

@@ -222,11 +222,14 @@ func initRevertTransactionData(t *testing.T) (context.Context, ClientInterface,
 	assert.NotEmpty(t, hex)
 
 	newOpts := client.DefaultModelOptions(WithXPub(testXPub), New())
-	transaction := newTransactionWithDraftID(
+	transaction, err := newTransactionWithDraftID(
 		hex, draftTransaction.ID, newOpts...,
 	)
+	require.NoError(t, err)
+
 	transaction.draftTransaction = draftTransaction
 	_hydrateOutgoingWithSync(transaction)
+
 	err = transaction.processUtxos(ctx)
 	require.NoError(t, err)
 

beef_bump.go

@@ -0,0 +1,174 @@
+package bux
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"sort"
+
+	"github.com/libsv/go-bt/v2"
+)
+
+func calculateMergedBUMP(txs []*Transaction) (BUMPs, error) {
+	bumps := make(map[uint64][]BUMP)
+	mergedBUMPs := make(BUMPs, 0)
+
+	for _, tx := range txs {
+		if tx.BUMP.BlockHeight == 0 || len(tx.BUMP.Path) == 0 {
+			continue
+		}
+
+		bumps[tx.BlockHeight] = append(bumps[tx.BlockHeight], tx.BUMP)
+	}
+
+	// ensure that BUMPs are sorted by block height and will always be put in beef in the same order
+	mapKeys := make([]uint64, 0, len(bumps))
+	for k := range bumps {
+		mapKeys = append(mapKeys, k)
+	}
+	sort.Slice(mapKeys, func(i, j int) bool { return mapKeys[i] < mapKeys[j] })
+
+	for _, k := range mapKeys {
+		bump, err := CalculateMergedBUMP(bumps[k])
+		if err != nil {
+			return nil, fmt.Errorf("Error while calculating Merged BUMP: %s", err.Error())
+		}
+		if bump == nil {
+			continue
+		}
+		mergedBUMPs = append(mergedBUMPs, bump)
+	}
+
+	return mergedBUMPs, nil
+}
+
+func validateBumps(bumps BUMPs) error {
+	if len(bumps) == 0 {
+		return errors.New("empty bump paths slice")
+	}
+
+	for _, p := range bumps {
+		if len(p.Path) == 0 {
+			return errors.New("one of bump path is empty")
+		}
+	}
+
+	return nil
+}
+
+func prepareBEEFFactors(ctx context.Context, tx *Transaction, store TransactionGetter) ([]*bt.Tx, []*Transaction, error) {
+	btTxsNeededForBUMP, txsNeededForBUMP, err := initializeRequiredTxsCollection(tx)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var txIDs []string
+	for _, input := range tx.draftTransaction.Configuration.Inputs {
+		txIDs = append(txIDs, input.UtxoPointer.TransactionID)
+	}
+
+	inputTxs, err := getRequiredTransactions(ctx, txIDs, store)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	for _, inputTx := range inputTxs {
+		inputBtTx, err := bt.NewTxFromString(inputTx.Hex)
+		if err != nil {
+			return nil, nil, fmt.Errorf("cannot convert to bt.Tx from hex (tx.ID: %s). Reason: %w", inputTx.ID, err)
+		}
+
+		txsNeededForBUMP = append(txsNeededForBUMP, inputTx)
+		btTxsNeededForBUMP = append(btTxsNeededForBUMP, inputBtTx)
+
+		if inputTx.BUMP.BlockHeight == 0 && len(inputTx.BUMP.Path) == 0 {
+			parentBtTransactions, parentTransactions, err := checkParentTransactions(ctx, store, inputBtTx)
+			if err != nil {
+				return nil, nil, err
+			}
+
+			txsNeededForBUMP = append(txsNeededForBUMP, parentTransactions...)
+			btTxsNeededForBUMP = append(btTxsNeededForBUMP, parentBtTransactions...)
+		}
+	}
+
+	return btTxsNeededForBUMP, txsNeededForBUMP, nil
+}
+
+func checkParentTransactions(ctx context.Context, store TransactionGetter, btTx *bt.Tx) ([]*bt.Tx, []*Transaction, error) {
+	var parentTxIDs []string
+	for _, txIn := range btTx.Inputs {
+		parentTxIDs = append(parentTxIDs, txIn.PreviousTxIDStr())
+	}
+
+	parentTxs, err := getRequiredTransactions(ctx, parentTxIDs, store)
+	if err != nil {
+		return nil, nil, err
+	}
+
+	var validTxs []*Transaction
+	var validBtTxs []*bt.Tx
+	for _, parentTx := range parentTxs {
+		parentBtTx, err := bt.NewTxFromString(parentTx.Hex)
+		if err != nil {
+			return nil, nil, fmt.Errorf("cannot convert to bt.Tx from hex (tx.ID: %s). Reason: %w", parentTx.ID, err)
+		}
+		validTxs = append(validTxs, parentTx)
+		validBtTxs = append(validBtTxs, parentBtTx)
+
+		if parentTx.BUMP.BlockHeight == 0 && len(parentTx.BUMP.Path) == 0 {
+			parentValidBtTxs, parentValidTxs, err := checkParentTransactions(ctx, store, parentBtTx)
+			if err != nil {
+				return nil, nil, err
+			}
+			validTxs = append(validTxs, parentValidTxs...)
+			validBtTxs = append(validBtTxs, parentValidBtTxs...)
+		}
+	}
+
+	return validBtTxs, validTxs, nil
+}
+
+func getRequiredTransactions(ctx context.Context, txIds []string, store TransactionGetter) ([]*Transaction, error) {
+	txs, err := store.GetTransactionsByIDs(ctx, txIds)
+	if err != nil {
+		return nil, fmt.Errorf("cannot get transactions from database: %w", err)
+	}
+
+	if len(txs) != len(txIds) {
+		missingTxIDs := getMissingTxs(txIds, txs)
+		return nil, fmt.Errorf("required transactions not found in database: %v", missingTxIDs)
+	}
+
+	return txs, nil
+}
+
+func getMissingTxs(txIDs []string, foundTxs []*Transaction) []string {
+	foundTxIDs := make(map[string]bool)
+	for _, tx := range foundTxs {
+		foundTxIDs[tx.ID] = true
+	}
+
+	var missingTxIDs []string
+	for _, txID := range txIDs {
+		if !foundTxIDs[txID] {
+			missingTxIDs = append(missingTxIDs, txID)
+		}
+	}
+	return missingTxIDs
+}
+
+func initializeRequiredTxsCollection(tx *Transaction) ([]*bt.Tx, []*Transaction, error) {
+	var btTxsNeededForBUMP []*bt.Tx
+	var txsNeededForBUMP []*Transaction
+
+	processedBtTx, err := bt.NewTxFromString(tx.Hex)
+	if err != nil {
+		return nil, nil, fmt.Errorf("cannot convert processed tx to bt.Tx from hex (tx.ID: %s). Reason: %w", tx.ID, err)
+	}
+
+	btTxsNeededForBUMP = append(btTxsNeededForBUMP, processedBtTx)
+	txsNeededForBUMP = append(txsNeededForBUMP, tx)
+
+	return btTxsNeededForBUMP, txsNeededForBUMP, nil
+}