MultiNode Integration: TOML Configurations

pkg/solana/chain.go

@@ -230,7 +230,7 @@ func newChain(id string, cfg *config.TOMLConfig, ks loop.Keystore, lggr logger.L
 		clientCache: map[string]*verifiedCachedClient{},
 	}
 
-	if cfg.MultiNodeEnabled() {
+	if cfg.MultiNode.MultiNodeEnabled() {
 		chainFamily := "solana"
 
 		mnCfg := cfg.MultiNodeConfig()
@@ -258,8 +258,8 @@ func newChain(id string, cfg *config.TOMLConfig, ks loop.Keystore, lggr logger.L
 
 		multiNode := mn.NewMultiNode[mn.StringID, *client.Client](
 			lggr,
-			mn.NodeSelectionModeRoundRobin,
-			0,
+			mnCfg.SelectionMode(),
+			mnCfg.LeaseDuration(),
 			nodes,
 			sendOnlyNodes,
 			mn.StringID(id),
@@ -398,7 +398,7 @@ func (c *chain) ChainID() string {
 
 // getClient returns a client, randomly selecting one from available and valid nodes
 func (c *chain) getClient() (client.ReaderWriter, error) {
-	if c.cfg.MultiNodeEnabled() {
+	if c.cfg.MultiNode.MultiNodeEnabled() {
 		return c.multiNode.SelectRPC()
 	}
 
@@ -482,7 +482,7 @@ func (c *chain) Start(ctx context.Context) error {
 		c.lggr.Debug("Starting balance monitor")
 		var ms services.MultiStart
 		startAll := []services.StartClose{c.txm, c.balanceMonitor}
-		if c.cfg.MultiNodeEnabled() {
+		if c.cfg.MultiNode.MultiNodeEnabled() {
 			c.lggr.Debug("Starting multinode")
 			startAll = append(startAll, c.multiNode, c.txSender)
 		}
@@ -496,7 +496,7 @@ func (c *chain) Close() error {
 		c.lggr.Debug("Stopping txm")
 		c.lggr.Debug("Stopping balance monitor")
 		closeAll := []io.Closer{c.txm, c.balanceMonitor}
-		if c.cfg.MultiNodeEnabled() {
+		if c.cfg.MultiNode.MultiNodeEnabled() {
 			c.lggr.Debug("Stopping multinode")
 			closeAll = append(closeAll, c.multiNode, c.txSender)
 		}

pkg/solana/config/multinode.go

@@ -1,87 +1,161 @@
 package config
 
-import "time"
+import (
+	"time"
+
+	"github.com/smartcontractkit/chainlink-common/pkg/config"
+
+	client "github.com/smartcontractkit/chainlink-solana/pkg/solana/client/multinode"
+)
 
 type MultiNode struct {
-	// TODO: Determine current config overlap https://smartcontract-it.atlassian.net/browse/BCI-4065
 	// Feature flag
-	multiNodeEnabled bool
+	multiNodeEnabled *bool
 
 	// Node Configs
-	pollFailureThreshold       uint32
-	pollInterval               time.Duration
-	selectionMode              string
-	syncThreshold              uint32
-	nodeIsSyncingEnabled       bool
-	finalizedBlockPollInterval time.Duration
-	enforceRepeatableRead      bool
-	deathDeclarationDelay      time.Duration
+	pollFailureThreshold       *uint32
+	pollInterval               *config.Duration
+	selectionMode              *string
+	syncThreshold              *uint32
+	nodeIsSyncingEnabled       *bool
+	leaseDuration              *config.Duration
+	finalizedBlockPollInterval *config.Duration
+	enforceRepeatableRead      *bool
+	deathDeclarationDelay      *config.Duration
 
 	// Chain Configs
-	nodeNoNewHeadsThreshold      time.Duration
-	noNewFinalizedHeadsThreshold time.Duration
-	finalityDepth                uint32
-	finalityTagEnabled           bool
-	finalizedBlockOffset         uint32
+	nodeNoNewHeadsThreshold      *config.Duration
+	noNewFinalizedHeadsThreshold *config.Duration
+	finalityDepth                *uint32
+	finalityTagEnabled           *bool
+	finalizedBlockOffset         *uint32
 }
 
 func (c *MultiNode) MultiNodeEnabled() bool {
-	return c.multiNodeEnabled
+	return c.multiNodeEnabled != nil && *c.multiNodeEnabled
 }
 
 func (c *MultiNode) PollFailureThreshold() uint32 {
-	return c.pollFailureThreshold
+	return *c.pollFailureThreshold
 }
 
 func (c *MultiNode) PollInterval() time.Duration {
-	return c.pollInterval
+	return c.pollInterval.Duration()
 }
 
 func (c *MultiNode) SelectionMode() string {
-	return c.selectionMode
+	return *c.selectionMode
 }
 
 func (c *MultiNode) SyncThreshold() uint32 {
-	return c.syncThreshold
+	return *c.syncThreshold
 }
 
 func (c *MultiNode) NodeIsSyncingEnabled() bool {
-	return c.nodeIsSyncingEnabled
+	return *c.nodeIsSyncingEnabled
 }
 
+func (c *MultiNode) LeaseDuration() time.Duration { return c.leaseDuration.Duration() }
+
 func (c *MultiNode) FinalizedBlockPollInterval() time.Duration {
-	return c.finalizedBlockPollInterval
+	return c.finalizedBlockPollInterval.Duration()
 }
 
-func (c *MultiNode) EnforceRepeatableRead() bool {
-	return c.enforceRepeatableRead
-}
+func (c *MultiNode) EnforceRepeatableRead() bool { return *c.enforceRepeatableRead }
 
-func (c *MultiNode) DeathDeclarationDelay() time.Duration {
-	return c.deathDeclarationDelay
-}
+func (c *MultiNode) DeathDeclarationDelay() time.Duration { return c.deathDeclarationDelay.Duration() }
 
 func (c *MultiNode) NodeNoNewHeadsThreshold() time.Duration {
-	return c.nodeNoNewHeadsThreshold
+	return c.nodeNoNewHeadsThreshold.Duration()
 }
 
 func (c *MultiNode) NoNewFinalizedHeadsThreshold() time.Duration {
-	return c.noNewFinalizedHeadsThreshold
+	return c.noNewFinalizedHeadsThreshold.Duration()
 }
 
-func (c *MultiNode) FinalityDepth() uint32 {
-	return c.finalityDepth
-}
+func (c *MultiNode) FinalityDepth() uint32 { return *c.finalityDepth }
 
-func (c *MultiNode) FinalityTagEnabled() bool {
-	return c.finalityTagEnabled
-}
+func (c *MultiNode) FinalityTagEnabled() bool { return *c.finalityTagEnabled }
 
-func (c *MultiNode) FinalizedBlockOffset() uint32 {
-	return c.finalizedBlockOffset
-}
+func (c *MultiNode) FinalizedBlockOffset() uint32 { return *c.finalizedBlockOffset }
 
 func (c *MultiNode) SetDefaults() {
-	// TODO: Set defaults for MultiNode config https://smartcontract-it.atlassian.net/browse/BCI-4065
-	c.multiNodeEnabled = false
+	// Default disabled
+	c.multiNodeEnabled = ptr(false)
+
+	// Node Configs
+	c.pollFailureThreshold = ptr(uint32(5))
+	c.pollInterval = config.MustNewDuration(10 * time.Second)
+
+	c.selectionMode = ptr(client.NodeSelectionModePriorityLevel)
+
+	c.syncThreshold = ptr(uint32(5))
+
+	c.leaseDuration = config.MustNewDuration(time.Minute)
+
+	c.nodeIsSyncingEnabled = ptr(false)
+	c.finalizedBlockPollInterval = config.MustNewDuration(5 * time.Second)
+	c.enforceRepeatableRead = ptr(true)
+	c.deathDeclarationDelay = config.MustNewDuration(10 * time.Second)
+
+	// Chain Configs
+	c.nodeNoNewHeadsThreshold = config.MustNewDuration(10 * time.Second)
+	c.noNewFinalizedHeadsThreshold = config.MustNewDuration(10 * time.Second)
+	c.finalityDepth = ptr(uint32(0))
+	c.finalityTagEnabled = ptr(true)
+	c.finalizedBlockOffset = ptr(uint32(0))
+}
+
+func (c *MultiNode) SetFrom(f *MultiNode) {
+	if f.multiNodeEnabled != nil {
+		c.multiNodeEnabled = f.multiNodeEnabled
+	}
+
+	// TODO: Try using reflection here to loop through each one
+
+	// Node Configs
+	if f.pollFailureThreshold != nil {
+		c.pollFailureThreshold = f.pollFailureThreshold
+	}
+	if f.pollInterval != nil {
+		c.pollInterval = f.pollInterval
+	}
+	if f.selectionMode != nil {
+		c.selectionMode = f.selectionMode
+	}
+	if f.syncThreshold != nil {
+		c.syncThreshold = f.syncThreshold
+	}
+	if f.nodeIsSyncingEnabled != nil {
+		c.nodeIsSyncingEnabled = f.nodeIsSyncingEnabled
+	}
+	if f.leaseDuration != nil {
+		c.leaseDuration = f.leaseDuration
+	}
+	if f.finalizedBlockPollInterval != nil {
+		c.finalizedBlockPollInterval = f.finalizedBlockPollInterval
+	}
+	if f.enforceRepeatableRead != nil {
+		c.enforceRepeatableRead = f.enforceRepeatableRead
+	}
+	if f.deathDeclarationDelay != nil {
+		c.deathDeclarationDelay = f.deathDeclarationDelay
+	}
+
+	// Chain Configs
+	if f.nodeNoNewHeadsThreshold != nil {
+		c.nodeNoNewHeadsThreshold = f.nodeNoNewHeadsThreshold
+	}
+	if f.noNewFinalizedHeadsThreshold != nil {
+		c.noNewFinalizedHeadsThreshold = f.noNewFinalizedHeadsThreshold
+	}
+	if f.finalityDepth != nil {
+		c.finalityDepth = f.finalityDepth
+	}
+	if f.finalityTagEnabled != nil {
+		c.finalityTagEnabled = f.finalityTagEnabled
+	}
+	if f.finalizedBlockOffset != nil {
+		c.finalizedBlockOffset = f.finalizedBlockOffset
+	}
 }

pkg/solana/config/toml.go

@@ -113,8 +113,8 @@ type TOMLConfig struct {
 	// Do not access directly, use [IsEnabled]
 	Enabled *bool
 	Chain
-	MultiNode
-	Nodes Nodes
+	MultiNode MultiNode
+	Nodes     Nodes
 }
 
 func (c *TOMLConfig) IsEnabled() bool {
@@ -130,6 +130,7 @@ func (c *TOMLConfig) SetFrom(f *TOMLConfig) {
 	}
 	setFromChain(&c.Chain, &f.Chain)
 	c.Nodes.SetFrom(&f.Nodes)
+	c.MultiNode.SetFrom(&f.MultiNode)
 }
 
 func setFromChain(c, f *Chain) {