From b4ce988bd5ff873c614596672319157c1ded03f8 Mon Sep 17 00:00:00 2001 From: george-dorin Date: Mon, 20 Jan 2025 15:02:56 +0200 Subject: [PATCH] -Fix tests --- .../features/ocr2/features_ocr2_helper.go | 2 +- .../features/ocr2/features_ocr2_test.go | 2 +- core/services/job/orm.go | 7 +- core/services/keystore/eth.go | 10 +-- core/services/keystore/keys/ethkey/models.go | 67 ------------------- core/services/keystore/mocks/eth.go | 16 +++-- core/services/keystore/models.go | 66 ++++++++++++++++++ core/services/ocrcommon/transmitter.go | 15 ++--- .../relay/evm/contract_transmitter.go | 10 +-- .../relay/evm/contract_transmitter_test.go | 13 +++- .../relay/evm/dual_contract_transmitter.go | 8 +-- core/services/relay/evm/evm.go | 1 + 12 files changed, 114 insertions(+), 103 deletions(-) diff --git a/core/internal/features/ocr2/features_ocr2_helper.go b/core/internal/features/ocr2/features_ocr2_helper.go index 9287d0df5b1..14b465ec6be 100644 --- a/core/internal/features/ocr2/features_ocr2_helper.go +++ b/core/internal/features/ocr2/features_ocr2_helper.go @@ -610,7 +610,7 @@ updateInterval = "1m" contractABI, err2 := abi.JSON(strings.NewReader(ocr2aggregator.OCR2AggregatorABI)) require.NoError(t, err2) apps[0].GetRelayers().LegacyEVMChains().Slice() - ct, err2 := evm.NewOCRContractTransmitter(testutils.Context(t), ocrContractAddress, apps[0].GetRelayers().LegacyEVMChains().Slice()[0].Client(), contractABI, nil, apps[0].GetRelayers().LegacyEVMChains().Slice()[0].LogPoller(), lggr) + ct, err2 := evm.NewOCRContractTransmitter(testutils.Context(t), ocrContractAddress, apps[0].GetRelayers().LegacyEVMChains().Slice()[0].Client(), contractABI, nil, apps[0].GetRelayers().LegacyEVMChains().Slice()[0].LogPoller(), lggr, apps[0].KeyStore.Eth()) require.NoError(t, err2) configDigest, epoch, err2 := ct.LatestConfigDigestAndEpoch(testutils.Context(t)) require.NoError(t, err2) diff --git a/core/internal/features/ocr2/features_ocr2_test.go b/core/internal/features/ocr2/features_ocr2_test.go index 01c269d19e3..6578a4a9aff 100644 --- a/core/internal/features/ocr2/features_ocr2_test.go +++ b/core/internal/features/ocr2/features_ocr2_test.go @@ -264,7 +264,7 @@ updateInterval = "1m" // Assert we can read the latest config digest and epoch after a report has been submitted. contractABI, err := abi.JSON(strings.NewReader(ocr2aggregator.OCR2AggregatorABI)) require.NoError(t, err) - ct, err := evm.NewOCRContractTransmitter(testutils.Context(t), ocrContractAddress, apps[0].GetRelayers().LegacyEVMChains().Slice()[0].Client(), contractABI, nil, apps[0].GetRelayers().LegacyEVMChains().Slice()[0].LogPoller(), lggr) + ct, err := evm.NewOCRContractTransmitter(testutils.Context(t), ocrContractAddress, apps[0].GetRelayers().LegacyEVMChains().Slice()[0].Client(), contractABI, nil, apps[0].GetRelayers().LegacyEVMChains().Slice()[0].LogPoller(), lggr, apps[0].KeyStore.Eth()) require.NoError(t, err) configDigest, epoch, err := ct.LatestConfigDigestAndEpoch(testutils.Context(t)) require.NoError(t, err) diff --git a/core/services/job/orm.go b/core/services/job/orm.go index 4099af2aae3..3f38d64b35f 100644 --- a/core/services/job/orm.go +++ b/core/services/job/orm.go @@ -30,7 +30,6 @@ import ( "github.com/smartcontractkit/chainlink/v2/core/logger" "github.com/smartcontractkit/chainlink/v2/core/null" "github.com/smartcontractkit/chainlink/v2/core/services/keystore" - "github.com/smartcontractkit/chainlink/v2/core/services/keystore/keys/ethkey" medianconfig "github.com/smartcontractkit/chainlink/v2/core/services/ocr2/plugins/median/config" "github.com/smartcontractkit/chainlink/v2/core/services/pipeline" "github.com/smartcontractkit/chainlink/v2/core/services/relay" @@ -347,7 +346,7 @@ func (o *orm) CreateJob(ctx context.Context, jb *Job) error { } //Check if secondary transmitter address is used as primary somewhere else - hasLock, err := checkIfKeyHasLock(ctx, tx.keyStore.Eth(), common.HexToAddress(dtTransmitterAddress), ethkey.TXMv1) + hasLock, err := checkIfKeyHasLock(ctx, tx.keyStore.Eth(), common.HexToAddress(dtTransmitterAddress), keystore.TXMv1) if err != nil { return err } else if hasLock { @@ -358,7 +357,7 @@ func (o *orm) CreateJob(ctx context.Context, jb *Job) error { //Check if primary transmitter address is used as secondary somewhere else, don't check for mercury as it uses CSA keys for transmitters if jb.OCR2OracleSpec.PluginType != types.Mercury { - hasLock, err := checkIfKeyHasLock(ctx, tx.keyStore.Eth(), common.HexToAddress(jb.OCR2OracleSpec.TransmitterID.String), ethkey.TXMv2) + hasLock, err := checkIfKeyHasLock(ctx, tx.keyStore.Eth(), common.HexToAddress(jb.OCR2OracleSpec.TransmitterID.String), keystore.TXMv2) if err != nil { return err } else if hasLock { @@ -1769,7 +1768,7 @@ func validateDualTransmissionMeta(meta map[string]interface{}) error { return nil } -func checkIfKeyHasLock(ctx context.Context, ks keystore.Eth, address common.Address, usage ethkey.ServiceType) (bool, error) { +func checkIfKeyHasLock(ctx context.Context, ks keystore.Eth, address common.Address, usage keystore.ServiceType) (bool, error) { rm, err := ks.GetResourceMutex(ctx, address) if err != nil { return false, err diff --git a/core/services/keystore/eth.go b/core/services/keystore/eth.go index a64939dd2ff..9417647507a 100644 --- a/core/services/keystore/eth.go +++ b/core/services/keystore/eth.go @@ -48,7 +48,7 @@ type Eth interface { GetStateForKey(ctx context.Context, key ethkey.KeyV2) (ethkey.State, error) GetStatesForChain(ctx context.Context, chainID *big.Int) ([]ethkey.State, error) EnabledAddressesForChain(ctx context.Context, chainID *big.Int) (addresses []common.Address, err error) - GetResourceMutex(ctx context.Context, address common.Address) (*ethkey.ResourceMutex, error) + GetResourceMutex(ctx context.Context, address common.Address) (*ResourceMutex, error) XXXTestingOnlySetState(ctx context.Context, keyState ethkey.State) XXXTestingOnlyAdd(ctx context.Context, key ethkey.KeyV2) @@ -60,11 +60,11 @@ type eth struct { ds sqlutil.DataSource subscribers [](chan struct{}) subscribersMu *sync.RWMutex - resourceMutex map[common.Address]*ethkey.ResourceMutex // ResourceMutex is an internal field and ought not be persisted to the database. Its main usage is to verify that the same key is not used for both TXMv1 and TXMv2 (usage in both TXMs will cause nonce drift and will lead to missing transactions). This functionality should be removed after we completely switch to TXMv2 + resourceMutex map[common.Address]*ResourceMutex // ResourceMutex is an internal field and ought not be persisted to the database. Its main usage is to verify that the same key is not used for both TXMv1 and TXMv2 (usage in both TXMs will cause nonce drift and will lead to missing transactions). This functionality should be removed after we completely switch to TXMv2 } // GetResourceMutex gets the resource mutex associates with the address if no resource mutex is found a new one is created -func (ks *eth) GetResourceMutex(ctx context.Context, address common.Address) (*ethkey.ResourceMutex, error) { +func (ks *eth) GetResourceMutex(ctx context.Context, address common.Address) (*ResourceMutex, error) { ks.lock.RLock() defer ks.lock.RUnlock() if ks.isLocked() { @@ -72,12 +72,12 @@ func (ks *eth) GetResourceMutex(ctx context.Context, address common.Address) (*e } if ks.resourceMutex == nil { - ks.resourceMutex = make(map[common.Address]*ethkey.ResourceMutex) + ks.resourceMutex = make(map[common.Address]*ResourceMutex) } _, exists := ks.resourceMutex[address] if !exists { - ks.resourceMutex[address] = ethkey.NewResourceMutex() + ks.resourceMutex[address] = NewResourceMutex() } return ks.resourceMutex[address], nil } diff --git a/core/services/keystore/keys/ethkey/models.go b/core/services/keystore/keys/ethkey/models.go index 7bf80d44282..43af2caffc5 100644 --- a/core/services/keystore/keys/ethkey/models.go +++ b/core/services/keystore/keys/ethkey/models.go @@ -1,8 +1,6 @@ package ethkey import ( - "errors" - "sync" "time" "github.com/smartcontractkit/chainlink/v2/core/chains/evm/types" @@ -19,17 +17,6 @@ type State struct { lastUsed time.Time } -type ResourceMutex struct { - mu sync.Mutex - activeCount map[ServiceType]int // Tracks active users per service type -} -type ServiceType int - -const ( - TXMv1 ServiceType = iota - TXMv2 -) - func (s State) KeyID() string { return s.Address.Hex() } @@ -43,57 +30,3 @@ func (s State) LastUsed() time.Time { func (s *State) WasUsed() { s.lastUsed = time.Now() } - -// TryLock attempts to lock the resource for the specified service type. -// It returns an error if the resource is locked by a different service type. -func (rm *ResourceMutex) TryLock(serviceType ServiceType) error { - rm.mu.Lock() - defer rm.mu.Unlock() - - // Check if other service types are using the resource - for otherServiceType, count := range rm.activeCount { - if otherServiceType != serviceType && count > 0 { - return errors.New("resource is locked by another service type") - } - } - - // Increment active count for the current service type - rm.activeCount[serviceType]++ - return nil -} - -// Unlock releases the lock for the service type -func (rm *ResourceMutex) Unlock(serviceType ServiceType) error { - rm.mu.Lock() - defer rm.mu.Unlock() - - // Check if the service type has an active lock - if rm.activeCount[serviceType] == 0 { - return errors.New("no active lock for this service type") - } - - // Decrement active count for the service type - rm.activeCount[serviceType]-- - if rm.activeCount[serviceType] == 0 { - delete(rm.activeCount, serviceType) - } - return nil -} - -// IsLocked checks if the resource is locked by any service or a specific service type. -func (rm *ResourceMutex) IsLocked(serviceType ServiceType) (bool, error) { - rm.mu.Lock() - defer rm.mu.Unlock() - - // Check if the resource is locked by the given service type - if count, exists := rm.activeCount[serviceType]; exists && count > 0 { - return true, nil - } - return false, nil -} - -func NewResourceMutex() *ResourceMutex { - return &ResourceMutex{ - activeCount: make(map[ServiceType]int), - } -} diff --git a/core/services/keystore/mocks/eth.go b/core/services/keystore/mocks/eth.go index 16e77f142d4..44892fa3059 100644 --- a/core/services/keystore/mocks/eth.go +++ b/core/services/keystore/mocks/eth.go @@ -10,6 +10,8 @@ import ( ethkey "github.com/smartcontractkit/chainlink/v2/core/services/keystore/keys/ethkey" + keystore "github.com/smartcontractkit/chainlink/v2/core/services/keystore" + mock "github.com/stretchr/testify/mock" types "github.com/ethereum/go-ethereum/core/types" @@ -703,23 +705,23 @@ func (_c *Eth_GetAll_Call) RunAndReturn(run func(context.Context) ([]ethkey.KeyV } // GetResourceMutex provides a mock function with given fields: ctx, address -func (_m *Eth) GetResourceMutex(ctx context.Context, address common.Address) (*ethkey.ResourceMutex, error) { +func (_m *Eth) GetResourceMutex(ctx context.Context, address common.Address) (*keystore.ResourceMutex, error) { ret := _m.Called(ctx, address) if len(ret) == 0 { panic("no return value specified for GetResourceMutex") } - var r0 *ethkey.ResourceMutex + var r0 *keystore.ResourceMutex var r1 error - if rf, ok := ret.Get(0).(func(context.Context, common.Address) (*ethkey.ResourceMutex, error)); ok { + if rf, ok := ret.Get(0).(func(context.Context, common.Address) (*keystore.ResourceMutex, error)); ok { return rf(ctx, address) } - if rf, ok := ret.Get(0).(func(context.Context, common.Address) *ethkey.ResourceMutex); ok { + if rf, ok := ret.Get(0).(func(context.Context, common.Address) *keystore.ResourceMutex); ok { r0 = rf(ctx, address) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(*ethkey.ResourceMutex) + r0 = ret.Get(0).(*keystore.ResourceMutex) } } @@ -751,12 +753,12 @@ func (_c *Eth_GetResourceMutex_Call) Run(run func(ctx context.Context, address c return _c } -func (_c *Eth_GetResourceMutex_Call) Return(_a0 *ethkey.ResourceMutex, _a1 error) *Eth_GetResourceMutex_Call { +func (_c *Eth_GetResourceMutex_Call) Return(_a0 *keystore.ResourceMutex, _a1 error) *Eth_GetResourceMutex_Call { _c.Call.Return(_a0, _a1) return _c } -func (_c *Eth_GetResourceMutex_Call) RunAndReturn(run func(context.Context, common.Address) (*ethkey.ResourceMutex, error)) *Eth_GetResourceMutex_Call { +func (_c *Eth_GetResourceMutex_Call) RunAndReturn(run func(context.Context, common.Address) (*keystore.ResourceMutex, error)) *Eth_GetResourceMutex_Call { _c.Call.Return(run) return _c } diff --git a/core/services/keystore/models.go b/core/services/keystore/models.go index 1ebc7480997..4e18cfab056 100644 --- a/core/services/keystore/models.go +++ b/core/services/keystore/models.go @@ -4,6 +4,7 @@ import ( "encoding/json" "fmt" "math/big" + "sync" "time" gethkeystore "github.com/ethereum/go-ethereum/accounts/keystore" @@ -423,3 +424,68 @@ func (rawKeys rawKeyRing) keys() (*keyRing, error) { func adulteratedPassword(password string) string { return "master-password-" + password } + +type ResourceMutex struct { + mu sync.Mutex + activeCount map[ServiceType]int // Tracks active users per service type +} +type ServiceType int + +const ( + TXMv1 ServiceType = iota + TXMv2 +) + +// TryLock attempts to lock the resource for the specified service type. +// It returns an error if the resource is locked by a different service type. +func (rm *ResourceMutex) TryLock(serviceType ServiceType) error { + rm.mu.Lock() + defer rm.mu.Unlock() + + // Check if other service types are using the resource + for otherServiceType, count := range rm.activeCount { + if otherServiceType != serviceType && count > 0 { + return errors.New("resource is locked by another service type") + } + } + + // Increment active count for the current service type + rm.activeCount[serviceType]++ + return nil +} + +// Unlock releases the lock for the service type +func (rm *ResourceMutex) Unlock(serviceType ServiceType) error { + rm.mu.Lock() + defer rm.mu.Unlock() + + // Check if the service type has an active lock + if rm.activeCount[serviceType] == 0 { + return errors.New("no active lock for this service type") + } + + // Decrement active count for the service type + rm.activeCount[serviceType]-- + if rm.activeCount[serviceType] == 0 { + delete(rm.activeCount, serviceType) + } + return nil +} + +// IsLocked checks if the resource is locked by any service or a specific service type. +func (rm *ResourceMutex) IsLocked(serviceType ServiceType) (bool, error) { + rm.mu.Lock() + defer rm.mu.Unlock() + + // Check if the resource is locked by the given service type + if count, exists := rm.activeCount[serviceType]; exists && count > 0 { + return true, nil + } + return false, nil +} + +func NewResourceMutex() *ResourceMutex { + return &ResourceMutex{ + activeCount: make(map[ServiceType]int), + } +} diff --git a/core/services/ocrcommon/transmitter.go b/core/services/ocrcommon/transmitter.go index 830425332af..d38b765a792 100644 --- a/core/services/ocrcommon/transmitter.go +++ b/core/services/ocrcommon/transmitter.go @@ -12,7 +12,6 @@ import ( "github.com/smartcontractkit/chainlink/v2/core/chains/evm/forwarders" "github.com/smartcontractkit/chainlink/v2/core/chains/evm/txmgr" "github.com/smartcontractkit/chainlink/v2/core/services/keystore" - "github.com/smartcontractkit/chainlink/v2/core/services/keystore/keys/ethkey" types2 "github.com/smartcontractkit/chainlink/v2/core/services/relay/evm/types" ) @@ -94,22 +93,22 @@ func NewOCR2FeedsTransmitter( strategy types.TxStrategy, checker txmgr.TransmitCheckerSpec, chainID *big.Int, - keystore keystore.Eth, + ks keystore.Eth, dualTransmissionConfig *types2.DualTransmissionConfig, ) (Transmitter, error) { // Ensure that a keystore is provided. - if keystore == nil { + if ks == nil { return nil, errors.New("nil keystore provided to transmitter") } - if hasLock, err := keyHasLock(ctx, keystore, effectiveTransmitterAddress, ethkey.TXMv2); err != nil { + if hasLock, err := keyHasLock(ctx, ks, effectiveTransmitterAddress, keystore.TXMv2); err != nil { return nil, err } else if hasLock { return nil, errors.Errorf("key %s is used as a secondary transmitter in another job. primary and secondary transmitters cannot be mixed", effectiveTransmitterAddress.String()) } if dualTransmissionConfig != nil { - if hasLock, err := keyHasLock(ctx, keystore, dualTransmissionConfig.TransmitterAddress, ethkey.TXMv1); err != nil { + if hasLock, err := keyHasLock(ctx, ks, dualTransmissionConfig.TransmitterAddress, keystore.TXMv1); err != nil { return nil, err } else if hasLock { return nil, errors.Errorf("key %s is used as a primary transmitter in another job. primary and secondary transmitters cannot be mixed", effectiveTransmitterAddress.String()) @@ -124,7 +123,7 @@ func NewOCR2FeedsTransmitter( strategy: strategy, checker: checker, chainID: chainID, - keystore: keystore, + keystore: ks, secondaryContractAddress: dualTransmissionConfig.ContractAddress, secondaryFromAddress: dualTransmissionConfig.TransmitterAddress, secondaryMeta: dualTransmissionConfig.Meta, @@ -141,7 +140,7 @@ func NewOCR2FeedsTransmitter( strategy: strategy, checker: checker, chainID: chainID, - keystore: keystore, + keystore: ks, }, }, nil } @@ -251,7 +250,7 @@ func (t *ocr2FeedsTransmitter) CreateSecondaryEthTransaction(ctx context.Context return errors.New("trying to send a secondary transmission on a non dual transmitter") } -func keyHasLock(ctx context.Context, ks keystore.Eth, address common.Address, service ethkey.ServiceType) (bool, error) { +func keyHasLock(ctx context.Context, ks keystore.Eth, address common.Address, service keystore.ServiceType) (bool, error) { rm, err := ks.GetResourceMutex(ctx, address) if err != nil { return false, err diff --git a/core/services/relay/evm/contract_transmitter.go b/core/services/relay/evm/contract_transmitter.go index 0e8f63258bc..bc903a820e7 100644 --- a/core/services/relay/evm/contract_transmitter.go +++ b/core/services/relay/evm/contract_transmitter.go @@ -17,13 +17,11 @@ import ( ocrtypes "github.com/smartcontractkit/libocr/offchainreporting2plus/types" "github.com/smartcontractkit/chainlink-common/pkg/logger" - "github.com/smartcontractkit/chainlink/v2/core/services/keystore" - "github.com/smartcontractkit/chainlink/v2/core/services/keystore/keys/ethkey" - "github.com/smartcontractkit/chainlink/v2/core/chains/evm/logpoller" "github.com/smartcontractkit/chainlink/v2/core/chains/evm/txmgr" "github.com/smartcontractkit/chainlink/v2/core/chains/evm/utils" "github.com/smartcontractkit/chainlink/v2/core/services" + "github.com/smartcontractkit/chainlink/v2/core/services/keystore" ) type ContractTransmitter interface { @@ -108,6 +106,7 @@ func NewOCRContractTransmitter( transmitter Transmitter, lp logpoller.LogPoller, lggr logger.Logger, + ks keystore.Eth, opts ...OCRTransmitterOption, ) (*contractTransmitter, error) { transmitted, ok := contractABI.Events["Transmitted"] @@ -123,6 +122,7 @@ func NewOCRContractTransmitter( lp: lp, contractReader: caller, lggr: logger.Named(lggr, "OCRContractTransmitter"), + ks: ks, transmitterOptions: &transmitterOps{ reportToEvmTxMeta: reportToEvmTxMetaNoop, excludeSigs: false, @@ -257,7 +257,7 @@ func (oc *contractTransmitter) Start(ctx context.Context) error { if err != nil { return err } - return rm.TryLock(ethkey.TXMv1) + return rm.TryLock(keystore.TXMv1) } func (oc *contractTransmitter) Close() error { //Unlock the transmitters to TXMv1 @@ -265,7 +265,7 @@ func (oc *contractTransmitter) Close() error { if err != nil { return err } - return rm.Unlock(ethkey.TXMv1) + return rm.Unlock(keystore.TXMv1) } // Has no state/lifecycle so it's always healthy and ready diff --git a/core/services/relay/evm/contract_transmitter_test.go b/core/services/relay/evm/contract_transmitter_test.go index 6106389f326..94bc4ae754c 100644 --- a/core/services/relay/evm/contract_transmitter_test.go +++ b/core/services/relay/evm/contract_transmitter_test.go @@ -17,7 +17,9 @@ import ( "github.com/smartcontractkit/chainlink/v2/core/chains/evm/logpoller" lpmocks "github.com/smartcontractkit/chainlink/v2/core/chains/evm/logpoller/mocks" "github.com/smartcontractkit/chainlink/v2/core/chains/evm/txmgr" + "github.com/smartcontractkit/chainlink/v2/core/internal/cltest" "github.com/smartcontractkit/chainlink/v2/core/internal/testutils" + "github.com/smartcontractkit/chainlink/v2/core/internal/testutils/pgtest" "github.com/smartcontractkit/chainlink/v2/core/logger" "github.com/smartcontractkit/libocr/commontypes" @@ -34,6 +36,10 @@ type mockTransmitter struct { lastPayload []byte } +func (m *mockTransmitter) SecondaryFromAddress(ctx context.Context) (gethcommon.Address, error) { + return gethcommon.Address{}, nil +} + func (m *mockTransmitter) CreateSecondaryEthTransaction(ctx context.Context, bytes []byte, meta *txmgr.TxMeta) error { return nil } @@ -47,11 +53,13 @@ func (*mockTransmitter) FromAddress(ctx context.Context) gethcommon.Address { re func TestContractTransmitter(t *testing.T) { t.Parallel() + db := pgtest.NewSqlxDB(t) lggr := logger.TestLogger(t) c := evmclimocks.NewClient(t) lp := lpmocks.NewLogPoller(t) ctx := testutils.Context(t) + ks := cltest.NewKeyStore(t, db) // scanLogs = false digestAndEpochDontScanLogs, _ := hex.DecodeString( "0000000000000000000000000000000000000000000000000000000000000000" + // false @@ -63,7 +71,7 @@ func TestContractTransmitter(t *testing.T) { reportToEvmTxMeta := func(b []byte) (*txmgr.TxMeta, error) { return &txmgr.TxMeta{}, nil } - ot, err := NewOCRContractTransmitter(ctx, gethcommon.Address{}, c, contractABI, &mockTransmitter{}, lp, lggr, + ot, err := NewOCRContractTransmitter(ctx, gethcommon.Address{}, c, contractABI, &mockTransmitter{}, lp, lggr, ks.Eth(), WithReportToEthMetadata(reportToEvmTxMeta)) require.NoError(t, err) digest, epoch, err := ot.LatestConfigDigestAndEpoch(testutils.Context(t)) @@ -157,6 +165,8 @@ func oneSignature() []ocrtypes.AttributedOnchainSignature { } func createContractTransmitter(ctx context.Context, t *testing.T, transmitter Transmitter, ops ...OCRTransmitterOption) *contractTransmitter { + db := pgtest.NewSqlxDB(t) + ethKeyStore := cltest.NewKeyStore(t, db).Eth() contractABI, err := abi.JSON(strings.NewReader(ocr2aggregator.OCR2AggregatorMetaData.ABI)) require.NoError(t, err) lp := lpmocks.NewLogPoller(t) @@ -169,6 +179,7 @@ func createContractTransmitter(ctx context.Context, t *testing.T, transmitter Tr transmitter, lp, logger.TestLogger(t), + ethKeyStore, ops..., ) require.NoError(t, err) diff --git a/core/services/relay/evm/dual_contract_transmitter.go b/core/services/relay/evm/dual_contract_transmitter.go index 35755fe3936..68ef7174af6 100644 --- a/core/services/relay/evm/dual_contract_transmitter.go +++ b/core/services/relay/evm/dual_contract_transmitter.go @@ -192,7 +192,7 @@ func (oc *dualContractTransmitter) lockTransmitters(ctx context.Context) error { if err != nil { return err } - if err = rmPrimary.TryLock(ethkey.TXMv1); err != nil { + if err = rmPrimary.TryLock(keystore.TXMv1); err != nil { return err } oc.lggr.Debugf("Key %s has been locked for TXMv1", primaryAddress.String()) @@ -207,7 +207,7 @@ func (oc *dualContractTransmitter) lockTransmitters(ctx context.Context) error { return err } - err = rmSecondary.TryLock(ethkey.TXMv2) + err = rmSecondary.TryLock(keystore.TXMv2) if err != nil { return err } @@ -221,7 +221,7 @@ func (oc *dualContractTransmitter) unlockTransmitters(ctx context.Context) error if err != nil { return err } - if err = rmPrimary.Unlock(ethkey.TXMv1); err != nil { + if err = rmPrimary.Unlock(keystore.TXMv1); err != nil { return err } oc.lggr.Debugf("Key %s has been unlocked for TXMv1", primaryAddress.String()) @@ -233,7 +233,7 @@ func (oc *dualContractTransmitter) unlockTransmitters(ctx context.Context) error if err != nil { return err } - err = rmSecondary.Unlock(ethkey.TXMv2) + err = rmSecondary.Unlock(keystore.TXMv2) if err != nil { return err } diff --git a/core/services/relay/evm/evm.go b/core/services/relay/evm/evm.go index 522e242c540..da6f80271dd 100644 --- a/core/services/relay/evm/evm.go +++ b/core/services/relay/evm/evm.go @@ -952,6 +952,7 @@ func newOnChainContractTransmitter(ctx context.Context, lggr logger.Logger, rarg transmitter, configWatcher.chain.LogPoller(), lggr, + ethKeystore, ocrTransmitterOpts..., ) }