Merge branch 'main' into DAPP-7236-ts-standard-tests

Author: jeffrifwaldsmartcontract

pkg/capabilities/consensus/ocr3/datafeeds/securemint_aggregator.go

@@ -126,7 +126,7 @@ func (f *evmReportFormatter) packReport(lggr logger.Logger, report *secureMintRe
 		map[EVMEncoderKey]any{
 			DataIDOutputFieldName:    f.dataID,
 			AnswerOutputFieldName:    smReportAsAnswer,
-			TimestampOutputFieldName: uint32(report.Block),
+			TimestampOutputFieldName: uint32(report.SeqNr),
 		},
 	}
 
@@ -166,13 +166,13 @@ func (f *solanaReportFormatter) packReport(lggr logger.Logger, report *secureMin
 	accountContextHash := sha256.Sum256(accounts)
 	lggr.Debugw("calculated account context hash", "accountContextHash", accountContextHash)
 
-	if report.Block > (1<<32 - 1) { // timestamp must fit in u32 in solana
-		return nil, fmt.Errorf("timestamp exceeds u32 bounds: %v", report.Block)
+	if report.SeqNr > (1<<32 - 1) { // timestamp must fit in u32 in solana
+		return nil, fmt.Errorf("timestamp exceeds u32 bounds: %v", report.SeqNr)
 	}
 
 	toWrap := []any{
 		map[SolanaEncoderKey]any{
-			SolTimestampOutputFieldName: uint32(report.Block), // TODO: Verify with Michael/Geert timestamp should be block number?
+			SolTimestampOutputFieldName: uint32(report.SeqNr),
 			SolAnswerOutputFieldName:    smReportAsAnswer,
 			SolDataIDOutputFieldName:    f.dataID,
 		},

pkg/capabilities/consensus/ocr3/datafeeds/securemint_aggregator_test.go

@@ -37,6 +37,7 @@ func TestSecureMintAggregator_Aggregate(t *testing.T) {
 		dataID               string
 		solAccounts          [][32]byte
 		previousOutcome      *types.AggregationOutcome
+		seqNr                uint64
 		observations         map[ocrcommon.OracleID][]values.Value
 		f                    int
 		expectedShouldReport bool
@@ -69,7 +70,7 @@ func TestSecureMintAggregator_Aggregate(t *testing.T) {
 		assert.NotNil(t, answer)
 
 		timestamp := report[TimestampOutputFieldName].(int64)
-		assert.Equal(t, int64(1000), timestamp)
+		assert.Equal(t, int64(tc.seqNr), timestamp)
 	}
 
 	solReportAssertFn := func(t *testing.T, tc tcase, topLevelMap map[string]any) {
@@ -100,14 +101,15 @@ func TestSecureMintAggregator_Aggregate(t *testing.T) {
 		assert.NotNil(t, answer)
 
 		timestamp := report[SolTimestampOutputFieldName].(int64)
-		assert.Equal(t, int64(1000), timestamp)
+		assert.Equal(t, int64(tc.seqNr), timestamp)
 	}
 
 	tests := []tcase{
 		{
 			name:          "successful eth report extraction",
 			chainSelector: "16015286601757825753",
 			dataID:        "0x01c508f42b0201320000000000000000",
+			seqNr:         10,
 			observations: createSecureMintObservations(t, []ocrTriggerEventData{
 				{
 					chainSelector: ethSepoliaChainSelector,
@@ -121,10 +123,10 @@ func TestSecureMintAggregator_Aggregate(t *testing.T) {
 				},
 				{
 					chainSelector: bnbTestnetChainSelector,
-					seqNr:         11,
+					seqNr:         10,
 					report: &secureMintReport{
 						ConfigDigest: ocr2types.ConfigDigest{0: 2, 31: 3},
-						SeqNr:        11,
+						SeqNr:        10,
 						Block:        1100,
 						Mintable:     big.NewInt(200),
 					},
@@ -139,6 +141,7 @@ func TestSecureMintAggregator_Aggregate(t *testing.T) {
 			name:          "no matching chain selector found",
 			chainSelector: "16015286601757825753",
 			dataID:        "0x01c508f42b0201320000000000000000",
+			seqNr:         10,
 			observations: createSecureMintObservations(t, []ocrTriggerEventData{
 				{
 					chainSelector: bnbTestnetChainSelector,
@@ -160,6 +163,7 @@ func TestSecureMintAggregator_Aggregate(t *testing.T) {
 			name:          "no observations",
 			chainSelector: "16015286601757825753",
 			dataID:        "0x01c508f42b0201320000000000000000",
+			seqNr:         10,
 			observations:  map[ocrcommon.OracleID][]values.Value{},
 			f:             1,
 			expectError:   true,
@@ -169,6 +173,7 @@ func TestSecureMintAggregator_Aggregate(t *testing.T) {
 			name:          "successful sol report extraction",
 			chainSelector: "16423721717087811551", // solana devnet
 			dataID:        "0x01c508f42b0201320000000000000000",
+			seqNr:         10,
 			solAccounts:   [][32]byte{acc1, acc2},
 			observations: createSecureMintObservations(t, []ocrTriggerEventData{
 				{
@@ -183,10 +188,10 @@ func TestSecureMintAggregator_Aggregate(t *testing.T) {
 				},
 				{
 					chainSelector: bnbTestnetChainSelector,
-					seqNr:         11,
+					seqNr:         10,
 					report: &secureMintReport{
 						ConfigDigest: ocr2types.ConfigDigest{0: 2, 31: 3},
-						SeqNr:        11,
+						SeqNr:        10,
 						Block:        1100,
 						Mintable:     big.NewInt(200),
 					},

pkg/config/rate.go

@@ -33,8 +33,8 @@ func ParseRate(s string) (Rate, error) {
 		}
 		rateLimit.Limit = rate.Every(d)
 	} else {
-		s = strings.TrimSuffix(s, "rps") // allowed but not required
-		f, err := strconv.ParseFloat(s, 64)
+		parts[0] = strings.TrimSuffix(parts[0], "rps") // allowed but not required
+		f, err := strconv.ParseFloat(parts[0], 64)
 		if err != nil {
 			return Rate{}, err
 		}

pkg/settings/cresettings/settings.go

@@ -2,7 +2,9 @@
 package cresettings
 
 import (
+	"encoding/json"
 	"log"
+	"os"
 	"time"
 
 	"golang.org/x/time/rate"
@@ -12,6 +14,12 @@ import (
 )
 
 func init() {
+	if v, ok := os.LookupEnv("CL_CRE_SETTINGS"); ok {
+		err := json.Unmarshal([]byte(v), &Default)
+		if err != nil {
+			log.Fatalf("failed to initialize defaults: %v", err)
+		}
+	}
 	err := InitConfig(&Default)
 	if err != nil {
 		log.Fatalf("failed to initialize keys: %v", err)

pkg/settings/cresettings/settings_test.go

@@ -7,9 +7,14 @@ import (
 	"log"
 	"os"
 	"testing"
+	"time"
 
 	"github.com/pelletier/go-toml/v2"
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"golang.org/x/time/rate"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/config"
 )
 
 var update = flag.Bool("update", false, "update the golden files of this test")
@@ -52,3 +57,54 @@ func TestDefault(t *testing.T) {
 		}
 	})
 }
+
+func TestSchema_Unmarshal(t *testing.T) {
+	cfg := Default
+	require.NoError(t, json.Unmarshal([]byte(`{
+	"WorkflowLimit": "500",
+	"HTTPTrigger": {
+		"AuthRateLimit": "200rps:50"
+	},
+	"PerOrg": {
+		"ZeroBalancePruningTimeout": "48h"
+	},
+	"PerOwner": {
+		"WorkflowExecutionConcurrencyLimit": "99"
+	},
+	"PerWorkflow": {
+		"WASMMemoryLimit": "250mb",
+		"CRONTrigger": {
+			"RateLimit": "every10s:5"
+		},
+		"HTTPTrigger": {
+			"IncomingPayloadSizeLimit": "14kb"
+		},
+		"LogTrigger": {
+			"EventRateLimit": "every13s:6"
+		},
+		"HTTPAction": {
+			"RateLimit": "every3s:5"
+		},
+		"ChainWrite": {
+			"EVM": {
+				"TransactionGasLimit": "500000"
+			}
+		},
+		"ChainRead": {
+			"CallLimit": "3"
+		}
+	}
+}`), &cfg))
+
+	assert.Equal(t, 500, cfg.WorkflowLimit.DefaultValue)
+	assert.Equal(t, config.Rate{Limit: 200, Burst: 50}, cfg.HTTPTrigger.AuthRateLimit.DefaultValue)
+	assert.Equal(t, 48*time.Hour, cfg.PerOrg.ZeroBalancePruningTimeout.DefaultValue)
+	assert.Equal(t, 99, cfg.PerOwner.WorkflowExecutionConcurrencyLimit.DefaultValue)
+	assert.Equal(t, 250*config.MByte, cfg.PerWorkflow.WASMMemoryLimit.DefaultValue)
+	assert.Equal(t, config.Rate{Limit: rate.Every(10 * time.Second), Burst: 5}, cfg.PerWorkflow.CRONTrigger.RateLimit.DefaultValue)
+	assert.Equal(t, 14*config.KByte, cfg.PerWorkflow.HTTPTrigger.IncomingPayloadSizeLimit.DefaultValue)
+	assert.Equal(t, config.Rate{Limit: rate.Every(13 * time.Second), Burst: 6}, cfg.PerWorkflow.LogTrigger.EventRateLimit.DefaultValue)
+	assert.Equal(t, config.Rate{Limit: rate.Every(3 * time.Second), Burst: 5}, cfg.PerWorkflow.HTTPAction.RateLimit.DefaultValue)
+	assert.Equal(t, 500000, cfg.PerWorkflow.ChainWrite.EVM.TransactionGasLimit.DefaultValue)
+	assert.Equal(t, 3, cfg.PerWorkflow.ChainRead.CallLimit.DefaultValue)
+}

pkg/settings/settings.go

@@ -44,6 +44,17 @@ func (s Setting[T]) MarshalText() ([]byte, error) {
 	return []byte(fmt.Sprintf("%v", s.DefaultValue)), nil
 }
 
+func (s *Setting[T]) UnmarshalText(b []byte) (err error) {
+	if len(b) >= 2 && b[0] == '"' && b[len(b)-1] == '"' {
+		b = b[1 : len(b)-1] // unquote string
+	}
+	s.DefaultValue, err = s.Parse(string(b))
+	if err != nil {
+		err = fmt.Errorf("%s: failed to parse %s: %w", s.Key, string(b), err)
+	}
+	return
+}
+
 func (s *Setting[T]) initSetting(key string, scope Scope, unit *string) error {
 	s.Key = key
 	s.Scope = scope

pkg/types/aptos/contract_reader.go

@@ -0,0 +1,82 @@
+package aptos
+
+import (
+	"github.com/smartcontractkit/chainlink-common/pkg/types"
+)
+
+type ContractReaderConfig struct {
+	IsLoopPlugin bool
+	Modules      map[string]*ContractReaderModule
+}
+
+type ContractReaderModule struct {
+	// The module name (optional). When not provided, the key in the map under which this module
+	// is stored is used.
+	Name      string
+	Functions map[string]*ContractReaderFunction
+	Events    map[string]*ContractReaderEvent
+}
+
+type ContractReaderFunction struct {
+	// The function name (optional). When not provided, the key in the map under which this function
+	// is stored is used.
+	Name   string
+	Params []FunctionParam
+
+	ResultFieldRenames  map[string]RenamedField
+	ResultTupleToStruct []string
+	ResultUnwrapStruct  []string
+}
+
+type FunctionParam struct {
+	// The function parameter name.
+	Name string
+	// The function parameter Move type.
+	Type string
+	// True if this is a required parameter, false otherwise.
+	Required bool
+	// If this is not a required parameter and it is not provided, this default value will be used.
+	DefaultValue any
+}
+
+type ContractReaderEvent struct {
+	// The struct where the event handle is defined.
+	EventHandleStructName string
+
+	// The name of the event handle field.
+	// This field can be defined as path to the nested
+	// struct that stores the event, e.g. "token_pool_state.burned_events"
+	EventHandleFieldName string
+
+	// The event account address.
+	// This field can be defined in several ways:
+	// - Empty string, which means the event account address is the address of the bound contract.
+	// - An exact address hex string (eg. 0x1234 or 1234) containing the events.
+	// - A fully qualified function name (eg. 0x1234::my_contract::get_event_address) which
+	//   takes no parameters and returns the actual event account address.
+	// - A name containing the module name and function name components
+	//   (eg. my_first_contract::get_event_address) stored at the address of the bound contract,
+	//   which takes no parameters and returns the actual event account address.
+	EventAccountAddress string
+
+	// Renames of event field names (optional). When not provided, the field names are used as-is.
+	EventFieldRenames map[string]RenamedField
+
+	// Renames provided filters to match the event field names (optional). When not provided, the filters are used as-is.
+	EventFilterRenames map[string]string
+}
+
+type RenamedField struct {
+	// The new field name (optional). This does not need to be provided if this field does not need
+	// to be renamed.
+	NewName string
+
+	// Rename sub-fields. This assumes that the event field value is a struct or a map with string keys.
+	SubFieldRenames map[string]RenamedField
+}
+
+type SequenceWithMetadata struct {
+	Sequence  types.Sequence
+	TxVersion uint64
+	TxHash    string
+}

pkg/types/aptos/contract_writer.go

@@ -0,0 +1,33 @@
+package aptos
+
+type FeeStrategy int
+
+const (
+	DeprioritizedFeeStrategy FeeStrategy = -1
+	DefaultFeeStrategy       FeeStrategy = 0
+	PrioritizedFeeStrategy   FeeStrategy = 1
+)
+
+type ContractWriterConfig struct {
+	Modules     map[string]*ContractWriterModule
+	FeeStrategy FeeStrategy
+}
+
+type ContractWriterModule struct {
+	// The module name (optional). When not provided, the key in the map under which this module
+	// is stored is used.
+	Name      string
+	Functions map[string]*ContractWriterFunction
+}
+
+type ContractWriterFunction struct {
+	// The function name (optional). When not provided, the key in the map under which this function
+	// is stored is used.
+	Name string
+	// The public key of the sending account.
+	PublicKey string
+	// The account address (optional). When not provided, the address is calculated
+	// from the public key.
+	FromAddress string
+	Params      []FunctionParam
+}

pkg/types/core/gateway_connector.go

@@ -3,6 +3,7 @@ package core
 import (
 	"context"
 	"encoding/json"
+	"fmt"
 
 	jsonrpc "github.com/smartcontractkit/chainlink-common/pkg/jsonrpc2"
 )
@@ -30,3 +31,31 @@ type GatewayConnectorHandler interface {
 	// HandleGatewayMessage is called when a message is received from a gateway
 	HandleGatewayMessage(ctx context.Context, gatewayID string, req *jsonrpc.Request[json.RawMessage]) error
 }
+
+var _ GatewayConnector = (*UnimplementedGatewayConnector)(nil)
+
+type UnimplementedGatewayConnector struct{}
+
+func (u *UnimplementedGatewayConnector) AddHandler(ctx context.Context, methods []string, handler GatewayConnectorHandler) error {
+	return fmt.Errorf("not implemented")
+}
+
+func (u *UnimplementedGatewayConnector) SendToGateway(ctx context.Context, gatewayID string, resp *jsonrpc.Response[json.RawMessage]) error {
+	return fmt.Errorf("not implemented")
+}
+
+func (u *UnimplementedGatewayConnector) SignMessage(ctx context.Context, msg []byte) ([]byte, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func (u *UnimplementedGatewayConnector) GatewayIDs(ctx context.Context) ([]string, error) {
+	return nil, fmt.Errorf("not implemented")
+}
+
+func (u *UnimplementedGatewayConnector) DonID(ctx context.Context) (string, error) {
+	return "", fmt.Errorf("not implemented")
+}
+
+func (u *UnimplementedGatewayConnector) AwaitConnection(ctx context.Context, gatewayID string) error {
+	return fmt.Errorf("not implemented")
+}