test cleanup

pkg/solana/chainreader/chain_reader_test.go

@@ -598,9 +598,10 @@ func (_m *mockedRPCClient) SetForAddress(pk solana.PublicKey, bts []byte, err er
 
 type chainReaderInterfaceTester struct {
 	TestSelectionSupport
-	conf    config.ContractReader
-	address []string
-	reader  *wrappedTestChainReader
+	conf        config.ContractReader
+	address     []string
+	reader      *wrappedTestChainReader
+	eventSource chainreader.EventSourcer
 }
 
 func (r *chainReaderInterfaceTester) GetAccountBytes(i int) []byte {
@@ -681,7 +682,7 @@ func (r *chainReaderInterfaceTester) Setup(t *testing.T) {
 
 func (r *chainReaderInterfaceTester) GetContractReader(t *testing.T) types.ContractReader {
 	client := new(mockedRPCClient)
-	svc, err := chainreader.NewContractReaderService(logger.Test(t), client, r.conf, nil)
+	svc, err := chainreader.NewContractReaderService(logger.Test(t), client, r.conf, r.eventSource)
 	if err != nil {
 		t.Logf("chain reader service was not able to start: %s", err.Error())
 		t.FailNow()

pkg/solana/logpoller/parser.go

@@ -15,13 +15,13 @@ import (
 )
 
 const (
-	blockFieldName     = "block_number"
-	chainIDFieldName   = "chain_id"
-	timestampFieldName = "block_timestamp"
-	txHashFieldName    = "tx_hash"
-	addressFieldName   = "address"
-	eventSigFieldName  = "event_sig"
-	defaultSort        = "block_number ASC, log_index ASC"
+	blockFieldName       = "block_number"
+	chainIDFieldName     = "chain_id"
+	timestampFieldName   = "block_timestamp"
+	txHashFieldName      = "tx_hash"
+	addressFieldName     = "address"
+	eventSubkeyFieldName = "event_subkey"
+	defaultSort          = "block_number ASC, log_index ASC"
 )
 
 var (
@@ -134,13 +134,11 @@ func (v *pgDSLParser) VisitEventSubkeyFilter(p *eventSubkeyFilter) {
 	// TODO: the value type will be the off-chain field type that a raw IDL codec would decode into
 	// this value will need to be wrapped in a special type that will encode the value properly for
 	// direct comparison.
-	/*
-		v.expression = fmt.Sprintf(
-			"%s = :%s",
-			eventSigFieldName,
-			v.args.withIndexedField(eventSigFieldName, p.eventSig),
-		)
-	*/
+	v.expression = fmt.Sprintf(
+		"%s = :%s",
+		eventSubkeyFieldName,
+		v.args.withIndexedField(eventSubkeyFieldName, p.Subkey),
+	)
 }
 
 func (v *pgDSLParser) buildQuery(

pkg/solana/logpoller/parser_test.go

@@ -53,15 +53,18 @@ func TestDSLParser(t *testing.T) {
 		parser := &pgDSLParser{}
 		expressions := []query.Expression{
 			NewAddressFilter(pk),
-			NewEventSubkeyFilter([]string{"test"}, nil),
+			NewEventSubkeyFilter([]string{"test"}, []primitives.ValueComparator{
+				{Value: 42, Operator: primitives.Gte},
+				{Value: "test_value", Operator: primitives.Eq},
+			}),
 			query.Confidence(primitives.Unconfirmed),
 		}
 		limiter := query.NewLimitAndSort(query.CursorLimit(fmt.Sprintf("10-5-%s", txHash), query.CursorFollowing, 20))
 
 		result, args, err := parser.buildQuery(chainID, expressions, limiter)
 		expected := logsQuery(
 			" WHERE chain_id = :chain_id " +
-				"AND (address = :address_0 AND event_sig = :event_sig_0) " +
+				"AND (address = :address_0 AND event_subkey = :event_subkey_0) " +
 				"AND (block_number > :cursor_block_number OR (block_number = :cursor_block_number " +
 				"AND log_index > :cursor_log_index)) " +
 				"ORDER BY block_number ASC, log_index ASC, tx_hash ASC LIMIT 20")
@@ -82,14 +85,17 @@ func TestDSLParser(t *testing.T) {
 		parser := &pgDSLParser{}
 		expressions := []query.Expression{
 			NewAddressFilter(pk),
-			NewEventSubkeyFilter([]string{"test"}, nil),
+			NewEventSubkeyFilter([]string{"test"}, []primitives.ValueComparator{
+				{Value: 42, Operator: primitives.Gte},
+				{Value: "test_value", Operator: primitives.Eq},
+			}),
 		}
 		limiter := query.NewLimitAndSort(query.CountLimit(20))
 
 		result, args, err := parser.buildQuery(chainID, expressions, limiter)
 		expected := logsQuery(
 			" WHERE chain_id = :chain_id " +
-				"AND (address = :address_0 AND event_sig = :event_sig_0) " +
+				"AND (address = :address_0 AND event_subkey = :event_subkey_0) " +
 				"ORDER BY " + defaultSort + " " +
 				"LIMIT 20")
 
@@ -237,9 +243,13 @@ func TestDSLParser(t *testing.T) {
 	t.Run("nested query deep", func(t *testing.T) {
 		t.Parallel()
 
-		sigFilter := NewEventSubkeyFilter([]string{"test"}, nil)
 		parser := &pgDSLParser{}
+		sigFilter := NewEventSubkeyFilter([]string{"test"}, []primitives.ValueComparator{
+			{Value: 42, Operator: primitives.Gte},
+			{Value: "test_value", Operator: primitives.Eq},
+		})
 
+		limiter := query.LimitAndSort{}
 		expressions := []query.Expression{
 			{BoolExpression: query.BoolExpression{
 				Expressions: []query.Expression{
@@ -261,13 +271,12 @@ func TestDSLParser(t *testing.T) {
 				BoolOperator: query.AND,
 			}},
 		}
-		limiter := query.LimitAndSort{}
 
 		result, args, err := parser.buildQuery(chainID, expressions, limiter)
 		expected := logsQuery(
 			" WHERE chain_id = :chain_id " +
 				"AND (block_timestamp = :block_timestamp_0 " +
-				"AND (tx_hash = :tx_hash_0 OR event_sig = :event_sig_0)) " +
+				"AND (tx_hash = :tx_hash_0 OR event_subkey = :event_subkey_0)) " +
 				"ORDER BY " + defaultSort)
 
 		require.NoError(t, err)