feat: filter governance events by address

Signed-off-by: Chris Gianelloni <wolf31o2@blinklabs.io>

Author: wolf31o2

filter/cardano/cardano.go

@@ -16,6 +16,7 @@ package cardano
 
 import (
 	"bytes"
+	"encoding/hex"
 	"sync"
 
 	"github.com/blinklabs-io/adder/event"
@@ -196,6 +197,57 @@ func (c *Cardano) matchAddressFilter(te event.TransactionEvent) bool {
 	return false
 }
 
+// matchAddressFilterGovernance checks if governance event matches address filters
+func (c *Cardano) matchAddressFilterGovernance(ge event.GovernanceEvent) bool {
+	// Check proposal procedures for reward account matches
+	for _, prop := range ge.ProposalProcedures {
+		// RewardAccount is a stake/reward address string
+		if _, exists := c.filterSet.addresses.stakeAddresses[prop.RewardAccount]; exists {
+			return true
+		}
+
+		// Check treasury withdrawal addresses if this is a treasury withdrawal action
+		if prop.ActionData.TreasuryWithdrawal != nil {
+			for _, withdrawal := range prop.ActionData.TreasuryWithdrawal.Withdrawals {
+				// Check against payment addresses
+				if _, exists := c.filterSet.addresses.paymentAddresses[withdrawal.Address]; exists {
+					return true
+				}
+				// Also check against stake addresses (some withdrawals may use stake addresses)
+				if _, exists := c.filterSet.addresses.stakeAddresses[withdrawal.Address]; exists {
+					return true
+				}
+			}
+		}
+	}
+
+	// Check vote delegation certificates for stake credential matches
+	if len(c.filterSet.addresses.stakeCredentialHashes) > 0 {
+		for _, cert := range ge.VoteDelegationCertificates {
+			// StakeCredential is a hex string of the credential hash (28 bytes)
+			credBytes, err := hex.DecodeString(cert.StakeCredential)
+			if err != nil {
+				continue
+			}
+			for _, filterHash := range c.filterSet.addresses.stakeCredentialHashes {
+				// filterHash may include header byte from bech32 decoding
+				// Compare against last 28 bytes (the actual credential hash)
+				var hashToCompare []byte
+				if len(filterHash) > 28 {
+					hashToCompare = filterHash[len(filterHash)-28:]
+				} else {
+					hashToCompare = filterHash
+				}
+				if bytes.Equal(credBytes, hashToCompare) {
+					return true
+				}
+			}
+		}
+	}
+
+	return false
+}
+
 // matchStakeCertificates checks certificates against stake credential hashes
 func (c *Cardano) matchStakeCertificates(certificates []ledger.Certificate) bool {
 	for _, certificate := range certificates {
@@ -262,13 +314,20 @@ func (c *Cardano) matchAssetFilter(te event.TransactionEvent) bool {
 
 // filterGovernanceEvent checks all applicable filters for governance events
 func (c *Cardano) filterGovernanceEvent(ge event.GovernanceEvent) bool {
+	// Check address filter
+	if c.filterSet.hasAddressFilter {
+		if !c.matchAddressFilterGovernance(ge) {
+			return false
+		}
+	}
+
 	// Check DRep filter
 	if c.filterSet.hasDRepFilter {
 		if !c.matchDRepFilterGovernance(ge) {
 			return false
 		}
 	}
-	// Future: pool filter, address filter for governance
+
 	return true
 }
 

filter/cardano/cardano_test.go

@@ -774,3 +774,182 @@ func TestFilterByPoolId(t *testing.T) {
 		t.Fatal("Test timed out waiting for filtered event")
 	}
 }
+
+func TestFilterByAddressGovernanceEvent(t *testing.T) {
+	// Use a stake/reward address format for proposal reward accounts
+	stakeAddr := "stake1uyehkck0lajq8gr28t9uxnuvgcqrc6070x3k9r8048z8y5gh6ffgw"
+	// 28 bytes = 56 hex chars for stake credential hash
+	stakeCredHex := "abcd1234567890abcdef1234567890abcdef1234567890abcdef1234"
+
+	t.Run("matches proposal reward account", func(t *testing.T) {
+		cs := New(WithAddresses([]string{stakeAddr}))
+
+		evt := event.Event{
+			Payload: event.GovernanceEvent{
+				ProposalProcedures: []event.ProposalProcedureData{
+					{
+						Index:         0,
+						Deposit:       100000000,
+						RewardAccount: stakeAddr,
+						ActionType:    "Info",
+					},
+				},
+			},
+		}
+
+		err := cs.Start()
+		assert.NoError(t, err)
+		defer cs.Stop()
+
+		cs.InputChan() <- evt
+
+		select {
+		case filteredEvt := <-cs.OutputChan():
+			assert.Equal(t, evt, filteredEvt)
+		case <-time.After(1 * time.Second):
+			t.Error("Expected event to pass filter but it didn't")
+		}
+	})
+
+	t.Run("matches treasury withdrawal address", func(t *testing.T) {
+		// Use a payment address for treasury withdrawal
+		paymentAddr := "addr1qx2fxv2umyhttkxyxp8x0dlpdt3k6cwng5pxj3jhsydzer3jcu5d8ps7zex2k2xt3uqxgjqnnj83ws8lhrn648jjxtwq2ytjqp"
+		cs := New(WithAddresses([]string{paymentAddr}))
+
+		evt := event.Event{
+			Payload: event.GovernanceEvent{
+				ProposalProcedures: []event.ProposalProcedureData{
+					{
+						Index:         0,
+						Deposit:       100000000000,
+						RewardAccount: "stake1...", // Different from filter
+						ActionType:    "TreasuryWithdrawal",
+						ActionData: event.GovActionData{
+							TreasuryWithdrawal: &event.TreasuryWithdrawalActionData{
+								Withdrawals: []event.TreasuryWithdrawalItem{
+									{
+										Address: paymentAddr,
+										Amount:  50000000000,
+									},
+								},
+							},
+						},
+					},
+				},
+			},
+		}
+
+		err := cs.Start()
+		assert.NoError(t, err)
+		defer cs.Stop()
+
+		cs.InputChan() <- evt
+
+		select {
+		case filteredEvt := <-cs.OutputChan():
+			assert.Equal(t, evt, filteredEvt)
+		case <-time.After(1 * time.Second):
+			t.Error("Expected event to pass filter but it didn't")
+		}
+	})
+
+	t.Run("matches vote delegation stake credential", func(t *testing.T) {
+		// Create a stake address that decodes to a credential hash
+		realStakeAddr := "stake1uyehkck0lajq8gr28t9uxnuvgcqrc6070x3k9r8048z8y5gh6ffgw"
+		cs := New(WithAddresses([]string{realStakeAddr}))
+
+		// Decode the stake address to get the actual credential hash
+		_, data, err := bech32.DecodeNoLimit(realStakeAddr)
+		assert.NoError(t, err)
+		converted, err := bech32.ConvertBits(data, 5, 8, false)
+		assert.NoError(t, err)
+		// Skip the first byte (header) to get the credential hash
+		credHash := hex.EncodeToString(converted[1:])
+
+		evt := event.Event{
+			Payload: event.GovernanceEvent{
+				VoteDelegationCertificates: []event.VoteDelegationCertificateData{
+					{
+						CertificateType: "VoteDelegation",
+						StakeCredential: credHash,
+						DRepType:        "KeyHash",
+						DRepHash:        "someDRepHash",
+					},
+				},
+			},
+		}
+
+		err = cs.Start()
+		assert.NoError(t, err)
+		defer cs.Stop()
+
+		cs.InputChan() <- evt
+
+		select {
+		case filteredEvt := <-cs.OutputChan():
+			assert.Equal(t, evt, filteredEvt)
+		case <-time.After(1 * time.Second):
+			t.Error("Expected event to pass filter but it didn't")
+		}
+	})
+
+	t.Run("does not match when address not in filter", func(t *testing.T) {
+		cs := New(WithAddresses([]string{stakeAddr}))
+
+		otherStakeAddr := "stake1uxxx..."
+		evt := event.Event{
+			Payload: event.GovernanceEvent{
+				ProposalProcedures: []event.ProposalProcedureData{
+					{
+						Index:         0,
+						RewardAccount: otherStakeAddr,
+						ActionType:    "Info",
+					},
+				},
+			},
+		}
+
+		err := cs.Start()
+		assert.NoError(t, err)
+		defer cs.Stop()
+
+		cs.InputChan() <- evt
+
+		select {
+		case <-cs.OutputChan():
+			t.Error("Expected event to be filtered out but it passed through")
+		case <-time.After(100 * time.Millisecond):
+			// Expected no event
+		}
+	})
+
+	t.Run("does not match governance event with no address data", func(t *testing.T) {
+		cs := New(WithAddresses([]string{stakeAddr}))
+
+		evt := event.Event{
+			Payload: event.GovernanceEvent{
+				// Only voting procedures, no addresses
+				VotingProcedures: []event.VotingProcedureData{
+					{
+						VoterType: "DRep",
+						VoterHash: stakeCredHex,
+						Vote:      "Yes",
+					},
+				},
+			},
+		}
+
+		err := cs.Start()
+		assert.NoError(t, err)
+		defer cs.Stop()
+
+		cs.InputChan() <- evt
+
+		select {
+		case <-cs.OutputChan():
+			t.Error("Expected event to be filtered out but it passed through")
+		case <-time.After(100 * time.Millisecond):
+			// Expected no event
+		}
+	})
+}