feat: new schema for phase2 indexer

client/schema.go

@@ -278,3 +278,52 @@ func NewConfirmedInfoEvent(height, tvl uint64) ConfirmedInfoEvent {
 		Tvl:           tvl,
 	}
 }
+
+type StakingEvent struct {
+	SchemaVersion             int       `json:"schema_version"`
+	EventType                 EventType `json:"event_type"`
+	StakingTxHashHex          string    `json:"staking_tx_hash_hex"`
+	StakerBtcPkHex            string    `json:"staker_btc_pk_hex"`
+	FinalityProviderBtcPksHex []string  `json:"finality_provider_btc_pks_hex"`
+	StakingAmount             uint64    `json:"staking_amount"`
+}
+
+func NewActiveStakingEventV2(
+	stakingTxHashHex string,
+	stakerBtcPkHex string,
+	finalityProviderBtcPksHex []string,
+	stakingAmount uint64,
+) StakingEvent {
+	return StakingEvent{
+		SchemaVersion:             ActiveEventVersion,
+		EventType:                 ActiveStakingEventType,
+		StakingTxHashHex:          stakingTxHashHex,
+		StakerBtcPkHex:            stakerBtcPkHex,
+		FinalityProviderBtcPksHex: finalityProviderBtcPksHex,
+		StakingAmount:             stakingAmount,
+	}
+}
+
+func NewUnbondingStakingEventV2(
+	stakingTxHashHex string,
+	stakerBtcPkHex string,
+	finalityProviderBtcPksHex []string,
+	stakingAmount uint64,
+) StakingEvent {
+	return StakingEvent{
+		SchemaVersion:             UnbondingEventVersion,
+		EventType:                 UnbondingStakingEventType,
+		StakingTxHashHex:          stakingTxHashHex,
+		StakerBtcPkHex:            stakerBtcPkHex,
+		FinalityProviderBtcPksHex: finalityProviderBtcPksHex,
+		StakingAmount:             stakingAmount,
+	}
+}
+
+func (e StakingEvent) GetEventType() EventType {
+	return e.EventType
+}
+
+func (e StakingEvent) GetStakingTxHashHex() string {
+	return e.StakingTxHashHex
+}

queuemngr/queue_manager.go

@@ -92,7 +92,7 @@ func PushEvent[T any](queueClient client.QueueClient, ev T) error {
 	return nil
 }
 
-func (qc *QueueManager) PushStakingEvent(ev *client.ActiveStakingEvent) error {
+func (qc *QueueManager) PushStakingEvent(ev *client.StakingEvent) error {
 	jsonBytes, err := json.Marshal(ev)
 	if err != nil {
 		return err
@@ -109,19 +109,19 @@ func (qc *QueueManager) PushStakingEvent(ev *client.ActiveStakingEvent) error {
 	return nil
 }
 
-func (qc *QueueManager) PushUnbondingEvent(ev *client.UnbondingStakingEvent) error {
+func (qc *QueueManager) PushUnbondingEvent(ev *client.StakingEvent) error {
 	jsonBytes, err := json.Marshal(ev)
 	if err != nil {
 		return err
 	}
 	messageBody := string(jsonBytes)
 
-	qc.logger.Info("pushing unbonding event", zap.String("staking_tx_hash", ev.UnbondingTxHashHex))
+	qc.logger.Info("pushing unbonding event", zap.String("staking_tx_hash", ev.StakingTxHashHex))
 	err = qc.UnbondingQueue.SendMessage(context.TODO(), messageBody)
 	if err != nil {
 		return fmt.Errorf("failed to push unbonding event: %w", err)
 	}
-	qc.logger.Info("successfully pushed unbonding event", zap.String("staking_tx_hash", ev.UnbondingTxHashHex))
+	qc.logger.Info("successfully pushed unbonding event", zap.String("staking_tx_hash", ev.StakingTxHashHex))
 
 	return nil
 }

tests/e2e_test.go

@@ -107,7 +107,7 @@ func TestSchemaVersionBackwardsCompatibility(t *testing.T) {
 	err = queuemngr.PushEvent(queueManager.StakingQueue, event)
 	require.NoError(t, err)
 	receivedEv := <-stakingEventReceivedChan
-	var stakingEv client.ActiveStakingEvent
+	var stakingEv client.StakingEvent
 	err = json.Unmarshal([]byte(receivedEv.Body), &stakingEv)
 	require.NoError(t, err)
 	require.Equal(t, event.EventType, stakingEv.GetEventType())
@@ -133,7 +133,7 @@ func TestStakingEvent(t *testing.T) {
 		require.NoError(t, err)
 
 		receivedEv := <-stakingEventReceivedChan
-		var stakingEv client.ActiveStakingEvent
+		var stakingEv client.StakingEvent
 		err := json.Unmarshal([]byte(receivedEv.Body), &stakingEv)
 		require.NoError(t, err)
 		require.Equal(t, ev, &stakingEv)
@@ -159,7 +159,7 @@ func TestUnbondingEvent(t *testing.T) {
 		require.NoError(t, err)
 
 		receivedEv := <-unbondingEvReceivedChan
-		var unbondingEv client.UnbondingStakingEvent
+		var unbondingEv client.StakingEvent
 		err := json.Unmarshal([]byte(receivedEv.Body), &unbondingEv)
 		require.NoError(t, err)
 		require.Equal(t, ev, &unbondingEv)
@@ -324,7 +324,7 @@ func TestReQueueEvent(t *testing.T) {
 		t.Fatal("timeout waiting for staking event")
 	}
 
-	var stakingEv client.ActiveStakingEvent
+	var stakingEv client.StakingEvent
 	err = json.Unmarshal([]byte(receivedEv.Body), &stakingEv)
 	require.NoError(t, err)
 	require.Equal(t, ev, &stakingEv)

tests/setup.go

@@ -4,7 +4,6 @@ import (
 	"fmt"
 	"strings"
 	"testing"
-	"time"
 
 	"github.com/rabbitmq/amqp091-go"
 	"github.com/stretchr/testify/require"
@@ -84,38 +83,29 @@ func purgeQueues(conn *amqp091.Connection, queues []string) error {
 	return nil
 }
 
-func buildActiveNStakingEvents(stakerHash string, numOfEvent int) []*client.ActiveStakingEvent {
-	var activeStakingEvents []*client.ActiveStakingEvent
+func buildActiveNStakingEvents(stakerHash string, numOfEvent int) []*client.StakingEvent {
+	var activeStakingEvents []*client.StakingEvent
 	for i := 0; i < numOfEvent; i++ {
-		activeStakingEvent := client.NewActiveStakingEvent(
+		activeStakingEvent := client.NewActiveStakingEventV2(
 			"0x1234567890abcdef"+fmt.Sprint(i),
 			stakerHash,
-			"0xabcdef1234567890"+fmt.Sprint(i),
+			[]string{"0xabcdef1234567890" + fmt.Sprint(i)},
 			1+uint64(i),
-			100+uint64(i),
-			time.Now().Unix(),
-			200+uint64(i),
-			1+uint64(i),
-			"0xabcdef1234567890"+fmt.Sprint(i),
-			false,
 		)
 
 		activeStakingEvents = append(activeStakingEvents, &activeStakingEvent)
 	}
 	return activeStakingEvents
 }
 
-func buildNUnbondingEvents(numOfEvent int) []*client.UnbondingStakingEvent {
-	var unbondingEvents []*client.UnbondingStakingEvent
+func buildNUnbondingEvents(numOfEvent int) []*client.StakingEvent {
+	var unbondingEvents []*client.StakingEvent
 	for i := 0; i < numOfEvent; i++ {
-		unbondingEv := client.NewUnbondingStakingEvent(
+		unbondingEv := client.NewUnbondingStakingEventV2(
 			"0x1234567890abcdef"+fmt.Sprint(i),
-			uint64(i),
-			time.Now().Unix(),
-			200+uint64(i),
-			uint64(0),
 			"0xabcdef1234567890"+fmt.Sprint(i),
-			"0x1234567890abcdef"+fmt.Sprint(i),
+			[]string{"0xabcdef1234567890" + fmt.Sprint(i)},
+			200+uint64(i),
 		)
 		unbondingEvents = append(unbondingEvents, &unbondingEv)
 	}