Merge branch 'develop' into fix/data-availability-fee

pkg/solana/chainreader/chain_reader.go

@@ -628,6 +628,7 @@ func (s *ContractReaderService) addEventRead(
 	reader.SetFilter(toLPFilter(readDefinition.ChainSpecificName, pf, subkeys.subKeys[:], eventDef))
 
 	s.bdRegistry.AddReader(namespace, genericName, reader)
+	s.lookup.addReadNameForContract(namespace, genericName, []read{{readName: genericName, useParams: false}})
 
 	return nil
 }

pkg/solana/chainreader/event_read_binding.go

@@ -33,7 +33,7 @@ type eventReadBinding struct {
 
 	// static data
 	namespace, genericName string
-	eventSig               [logpoller.EventSignatureLength]byte
+	eventSig               logpoller.EventSignature
 	indexedSubKeys         *indexedSubkeys
 	readDefinition         config.ReadDefinition
 
@@ -210,7 +210,7 @@ func (b *eventReadBinding) GetLatestValue(ctx context.Context, params, returnVal
 
 	allFilters := []query.Expression{
 		logpoller.NewAddressFilter(pubKey),
-		logpoller.NewEventSigFilter(b.eventSig[:]),
+		logpoller.NewEventSigFilter(b.eventSig),
 	}
 
 	if len(subkeyFilters) > 0 {
@@ -258,7 +258,7 @@ func (b *eventReadBinding) QueryKey(
 	// filter should always use the address and event sig
 	filter.Expressions = append([]query.Expression{
 		logpoller.NewAddressFilter(pubKey),
-		logpoller.NewEventSigFilter(b.eventSig[:]),
+		logpoller.NewEventSigFilter(b.eventSig),
 	}, filter.Expressions...)
 
 	itemType := strings.Join([]string{b.namespace, b.genericName}, ".")

pkg/solana/codec/parsed_types_test.go

@@ -0,0 +1,90 @@
+package codec_test
+
+import (
+	"encoding/json"
+	"fmt"
+	"math/big"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+
+	commoncodec "github.com/smartcontractkit/chainlink-common/pkg/codec"
+	"github.com/smartcontractkit/chainlink-common/pkg/utils/tests"
+
+	"github.com/smartcontractkit/chainlink-solana/pkg/solana/codec"
+)
+
+func TestEncodeDecodeBigInt(t *testing.T) {
+	t.Parallel()
+
+	type offChain struct {
+		A *big.Int
+		B *big.Int
+	}
+
+	ctx := tests.Context(t)
+	types := newTestCodec(t)
+	typedCodec, err := types.ToCodec()
+
+	require.NoError(t, err)
+
+	value := offChain{
+		A: big.NewInt(42),
+		B: big.NewInt(42),
+	}
+
+	bts, err := typedCodec.Encode(ctx, &value, codec.WrapItemType(true, namespace, genericName))
+
+	require.NoError(t, err)
+
+	var output offChain
+
+	require.NoError(t, typedCodec.Decode(ctx, bts, &output, codec.WrapItemType(false, namespace, genericName)))
+	require.Equal(t, value.A.String(), output.A.String())
+	require.Equal(t, value.B.String(), output.B.String())
+}
+
+func newTestCodec(t *testing.T) *codec.ParsedTypes {
+	t.Helper()
+
+	rawIDL := fmt.Sprintf(basicEventIDL, testParamType)
+
+	var IDL codec.IDL
+	require.NoError(t, json.Unmarshal([]byte(rawIDL), &IDL))
+
+	idlDef, err := codec.FindDefinitionFromIDL(codec.ChainConfigTypeEventDef, "EventType", IDL)
+
+	require.NoError(t, err)
+
+	mods := commoncodec.MultiModifier{
+		commoncodec.NewRenamer(map[string]string{"X": "A", "Y": "B"}),
+	}
+
+	entry, err := codec.CreateCodecEntry(idlDef, "GenericName", IDL, mods)
+
+	require.NoError(t, err)
+
+	return &codec.ParsedTypes{
+		EncoderDefs: map[string]codec.Entry{codec.WrapItemType(true, namespace, genericName): entry},
+		DecoderDefs: map[string]codec.Entry{codec.WrapItemType(false, namespace, genericName): entry},
+	}
+}
+
+const (
+	namespace   = "TestNamespace"
+	genericName = "GenericName"
+
+	basicEventIDL = `{
+		"version": "0.1.0",
+		"name": "some_test_idl",
+		"events": [%s]
+	}`
+
+	testParamType = `{
+		"name": "EventType",
+		"fields": [
+			{"name": "x", "type": "i128"},
+			{"name": "y", "type": "u128"}
+		]
+	}`
+)

pkg/solana/codec/solana.go

@@ -430,7 +430,7 @@ func getUIntCodecByStringType(curType IdlTypeAsString, builder commonencodings.B
 	case IdlTypeU64:
 		return builder.Uint64(), nil
 	case IdlTypeU128:
-		return builder.BigInt(16, true)
+		return builder.BigInt(16, false)
 	default:
 		return nil, fmt.Errorf(unknownIDLFormat, commontypes.ErrInvalidConfig, curType)
 	}

pkg/solana/logpoller/loader.go

@@ -21,15 +21,6 @@ type Block struct {
 	Events     []ProgramEvent
 }
 
-type ProgramEventProcessor interface {
-	// Process should take a ProgramEvent and parseProgramLogs it based on log signature
-	// and expected encoding. Only return errors that cannot be handled and
-	// should exit further transaction processing on the running thread.
-	//
-	// Process should be thread safe.
-	Process(Block) error
-}
-
 type RPCClient interface {
 	GetBlockWithOpts(context.Context, uint64, *rpc.GetBlockOpts) (*rpc.GetBlockResult, error)
 	GetSignaturesForAddressWithOpts(context.Context, solana.PublicKey, *rpc.GetSignaturesForAddressOpts) ([]*rpc.TransactionSignature, error)

pkg/solana/logpoller/log_poller.go

@@ -175,17 +175,23 @@ func (lp *Service) Process(ctx context.Context, programEvent ProgramEvent) (err
 			return err
 		}
 
-		log.SubkeyValues = make([]IndexedValue, 0, len(filter.SubkeyPaths))
-		for _, path := range filter.SubkeyPaths {
+		log.SubkeyValues = make([]IndexedValue, len(filter.SubkeyPaths))
+		for idx, path := range filter.SubkeyPaths {
+			if len(path) == 0 {
+				continue
+			}
+
 			subKeyVal, decodeSubKeyErr := lp.filters.DecodeSubKey(ctx, lp.lggr, log.Data, filter.ID, path)
 			if decodeSubKeyErr != nil {
 				return decodeSubKeyErr
 			}
+
 			indexedVal, newIndexedValErr := newIndexedValue(subKeyVal)
 			if newIndexedValErr != nil {
 				return newIndexedValErr
 			}
-			log.SubkeyValues = append(log.SubkeyValues, indexedVal)
+
+			log.SubkeyValues[idx] = indexedVal
 		}
 
 		log.SequenceNum = lp.filters.IncrementSeqNum(filter.ID)

pkg/solana/logpoller/parser.go

@@ -21,7 +21,7 @@ const (
 	txHashFieldName       = "tx_hash"
 	addressFieldName      = "address"
 	eventSigFieldName     = "event_sig"
-	defaultSort           = "block_number ASC, log_index ASC"
+	defaultSort           = "block_number DESC, log_index DESC"
 	subKeyValuesFieldName = "subkey_values"
 	subKeyValueArg        = "subkey_value"
 	subKeyIndexArgName    = "subkey_index"
@@ -412,12 +412,12 @@ func orderToString(dir query.SortDirection) (string, error) {
 }
 
 type addressFilter struct {
-	address solana.PublicKey
+	address PublicKey
 }
 
 func NewAddressFilter(address solana.PublicKey) query.Expression {
 	return query.Expression{
-		Primitive: &addressFilter{address: address},
+		Primitive: &addressFilter{address: PublicKey(address)},
 	}
 }
 
@@ -429,10 +429,10 @@ func (f *addressFilter) Accept(visitor primitives.Visitor) {
 }
 
 type eventSigFilter struct {
-	eventSig []byte
+	eventSig EventSignature
 }
 
-func NewEventSigFilter(sig []byte) query.Expression {
+func NewEventSigFilter(sig EventSignature) query.Expression {
 	return query.Expression{
 		Primitive: &eventSigFilter{eventSig: sig},
 	}

pkg/solana/logpoller/parser_test.go

@@ -60,7 +60,7 @@ func TestDSLParser(t *testing.T) {
 		parser := &pgDSLParser{}
 		expressions := []query.Expression{
 			NewAddressFilter(pk),
-			NewEventSigFilter([]byte("test")),
+			NewEventSigFilter(NewEventSignatureFromName("TestEvent")),
 			subkey,
 			query.Confidence(primitives.Unconfirmed),
 		}
@@ -98,7 +98,7 @@ func TestDSLParser(t *testing.T) {
 		parser := &pgDSLParser{}
 		expressions := []query.Expression{
 			NewAddressFilter(pk),
-			NewEventSigFilter([]byte("test")),
+			NewEventSigFilter(NewEventSignatureFromName("TestEvent")),
 			subkey,
 		}
 		limiter := query.NewLimitAndSort(query.CountLimit(20))
@@ -297,7 +297,7 @@ func TestDSLParser(t *testing.T) {
 		t.Parallel()
 
 		parser := &pgDSLParser{}
-		sigFilter := NewEventSigFilter([]byte("test"))
+		sigFilter := NewEventSigFilter(NewEventSignatureFromName("TestEvent"))
 
 		limiter := query.LimitAndSort{}
 		expressions := []query.Expression{