Merge branch 'multi-address-output-support' into 'main'

Multi address output support

See merge request flarenetwork/network/flare-p-chain-indexer!4

Author: mboben

indexer/shared/base_tx.go

@@ -11,21 +11,22 @@ import (
 	"github.com/ava-labs/avalanchego/vms/secp256k1fx"
 )
 
-// Create database outputs from TransferableOutputs, provided their type is *secp256k1fx.TransferOutput and the
-// number of addresses for each output is 1. Error is returned if these two conditions
-// are not met.
-func OutputsFromTxOuts(txID string, outs []*avax.TransferableOutput, startIndex int, creator OutputCreator) ([]Output, error) {
-	txOuts := make([]Output, len(outs))
+// Create database outputs from TransferableOutputs, provided their type is *secp256k1fx.TransferOutput
+func OutputsFromTxOuts(
+	txID string,
+	outs []*avax.TransferableOutput,
+	startIndex int,
+	creator OutputCreator,
+) ([]Output, error) {
+	txOuts := make([]Output, 0, len(outs))
 	for outi, cout := range outs {
-		dbOut := &database.TxOutput{
-			TxID: txID,
-			Idx:  uint32(outi + startIndex),
-		}
-		err := UpdateTransferableOutput(dbOut, cout.Out)
+		dbOuts, err := CreateTransferableOutputs(txID, uint32(outi+startIndex), cout.Out)
 		if err != nil {
 			return nil, err
 		}
-		txOuts[outi] = creator.CreateOutput(dbOut)
+		for _, dbOut := range dbOuts {
+			txOuts = append(txOuts, creator.CreateOutput(dbOut))
+		}
 	}
 	return txOuts, nil
 }
@@ -69,6 +70,34 @@ func UpdateTransferableOutput(dbOut *database.TxOutput, out verify.State) error
 	return nil
 }
 
+// Create database outputs from out provided its type is *secp256k1fx.TransferOutput.
+// Note that multiple database outputs are created if there are multiple addresses in out.
+func CreateTransferableOutputs(
+	txID string,
+	idx uint32,
+	out verify.State,
+) ([]*database.TxOutput, error) {
+	to, ok := out.(*secp256k1fx.TransferOutput)
+	if !ok {
+		return nil, fmt.Errorf("TransferableOutput has unsupported type")
+	}
+	dbOuts := make([]*database.TxOutput, len(to.Addrs))
+	for i, addr := range to.Addrs {
+		formattedAddr, err := chain.FormatAddressBytes(addr.Bytes())
+		if err != nil {
+			return nil, err
+		}
+		dbOut := &database.TxOutput{
+			TxID:    txID,
+			Idx:     idx,
+			Amount:  to.Amount(),
+			Address: formattedAddr,
+		}
+		dbOuts[i] = dbOut
+	}
+	return dbOuts, nil
+}
+
 // Return address from Owner interface provided its type is *secp256k1fx.OutputOwners and the
 // number of addresses is 1. Error is returned if these two conditions are not met.
 func RewardsOwnerAddress(owner fx.Owner) (string, error) {

indexer/shared/constants.go

@@ -5,7 +5,7 @@ import (
 )
 
 const (
-	ApplicationVersion = "2.2.2"
+	ApplicationVersion = "2.2.3-rc1"
 )
 
 var (

utils/staking/utils.go

@@ -200,7 +200,15 @@ func DedupeTxs(txs []database.PChainTxData) []database.PChainTxData {
 			continue
 		}
 
-		txSet[*tx.TxID] = tx
+		if setTx, exists := txSet[*tx.TxID]; exists {
+			// If there is already a tx with this txID and index 0, keep the one with the
+			// lexically smallest input address
+			if tx.InputAddress < setTx.InputAddress {
+				txSet[*tx.TxID] = tx
+			}
+		} else {
+			txSet[*tx.TxID] = tx
+		}
 	}
 
 	dedupedTxs := make([]database.PChainTxData, 0, len(txSet))

utils/staking/utils_test.go

@@ -0,0 +1,58 @@
+package staking
+
+import (
+	"flare-indexer/database"
+	"testing"
+)
+
+func testPChainTxData(id uint64, txID string, inputAddress string, inputIndex int) database.PChainTxData {
+	tx := database.PChainTxData{
+		PChainTx: database.PChainTx{
+			BaseEntity: database.BaseEntity{ID: id},
+			TxID:       &txID,
+		},
+		InputAddress: inputAddress,
+		InputIndex:   uint32(inputIndex),
+	}
+	return tx
+}
+
+func TestDedupeTxs(t *testing.T) {
+	testPChainTxData := []database.PChainTxData{
+		testPChainTxData(1, "tx1", "addr2", 0),
+		testPChainTxData(2, "tx1", "addr1", 0),
+		testPChainTxData(3, "tx1", "addr3", 1),
+		testPChainTxData(4, "tx2", "addr4", 0),
+		testPChainTxData(6, "tx3", "addr1", 0),
+		testPChainTxData(5, "tx3", "addr2", 0),
+		testPChainTxData(7, "tx3", "addr6", 1),
+		testPChainTxData(8, "tx3", "addr7", 1),
+		testPChainTxData(9, "tx4", "addr1", 0),
+		testPChainTxData(10, "tx4", "addr2", 0),
+	}
+
+	dedupedTxs := DedupeTxs(testPChainTxData)
+
+	expectedSequence := [][]string{
+		{"tx1", "addr1"},
+		{"tx2", "addr4"},
+		{"tx3", "addr1"},
+		{"tx4", "addr1"},
+	}
+
+	if len(dedupedTxs) != len(expectedSequence) {
+		t.Fatalf("Expected %d deduped txs, got %d", len(expectedSequence), len(dedupedTxs))
+	}
+
+	for i, tx := range dedupedTxs {
+		expectedTxID := expectedSequence[i][0]
+		expectedAddress := expectedSequence[i][1]
+		if *tx.TxID != expectedTxID {
+			t.Errorf("At index %d, expected TxID %s, got %s", i, expectedTxID, *tx.TxID)
+		}
+		if tx.InputAddress != expectedAddress {
+			t.Errorf("At index %d, expected InputAddress %s, got %s", i, expectedAddress, tx.InputAddress)
+		}
+	}
+
+}