Provide private key to Eth endpoint

command/bridge/helper/utils.go

@@ -7,19 +7,20 @@ import (
 	"fmt"
 	"math/big"
 
+	dockertypes "github.com/docker/docker/api/types"
+	"github.com/docker/docker/client"
+	"github.com/umbracle/ethgo"
+	"github.com/umbracle/ethgo/wallet"
+
 	polybftsecrets "github.com/0xPolygon/polygon-edge/command/secrets/init"
 	"github.com/0xPolygon/polygon-edge/consensus/polybft"
 	"github.com/0xPolygon/polygon-edge/consensus/polybft/contractsapi"
-	polybftWallet "github.com/0xPolygon/polygon-edge/consensus/polybft/wallet"
+	polyWallet "github.com/0xPolygon/polygon-edge/consensus/polybft/wallet"
 	"github.com/0xPolygon/polygon-edge/contracts"
 	"github.com/0xPolygon/polygon-edge/helper/common"
 	"github.com/0xPolygon/polygon-edge/helper/hex"
 	"github.com/0xPolygon/polygon-edge/txrelayer"
 	"github.com/0xPolygon/polygon-edge/types"
-	dockertypes "github.com/docker/docker/api/types"
-	"github.com/docker/docker/client"
-	"github.com/umbracle/ethgo"
-	"github.com/umbracle/ethgo/wallet"
 )
 
 //nolint:gosec
@@ -146,7 +147,7 @@ func GetECDSAKey(privateKey, accountDir, accountConfig string) (ethgo.Key, error
 		return nil, err
 	}
 
-	return polybftWallet.GetEcdsaFromSecret(secretsManager)
+	return polyWallet.GetEcdsaFromSecret(secretsManager)
 }
 
 // GetValidatorInfo queries SupernetManager smart contract on root

consensus/polybft/wallet/account.go

@@ -51,41 +51,6 @@ func NewAccountFromSecret(secretsManager secrets.SecretsManager) (*Account, erro
 	return &Account{Ecdsa: ecdsaKey, Bls: blsKey}, nil
 }
 
-// GetEcdsaFromSecret retrieves validator(ECDSA) key by using provided secretsManager
-func GetEcdsaFromSecret(secretsManager secrets.SecretsManager) (*wallet.Key, error) {
-	encodedKey, err := secretsManager.GetSecret(secrets.ValidatorKey)
-	if err != nil {
-		return nil, fmt.Errorf("failed to retrieve ecdsa key: %w", err)
-	}
-
-	ecdsaRaw, err := hex.DecodeString(string(encodedKey))
-	if err != nil {
-		return nil, fmt.Errorf("failed to retrieve ecdsa key: %w", err)
-	}
-
-	key, err := wallet.NewWalletFromPrivKey(ecdsaRaw)
-	if err != nil {
-		return nil, fmt.Errorf("failed to retrieve ecdsa key: %w", err)
-	}
-
-	return key, nil
-}
-
-// GetBlsFromSecret retrieves BLS key by using provided secretsManager
-func GetBlsFromSecret(secretsManager secrets.SecretsManager) (*bls.PrivateKey, error) {
-	encodedKey, err := secretsManager.GetSecret(secrets.ValidatorBLSKey)
-	if err != nil {
-		return nil, fmt.Errorf("failed to retrieve bls key: %w", err)
-	}
-
-	blsKey, err := bls.UnmarshalPrivateKey(encodedKey)
-	if err != nil {
-		return nil, fmt.Errorf("failed to retrieve bls key: %w", err)
-	}
-
-	return blsKey, nil
-}
-
 // Save persists ECDSA and BLS private keys to the SecretsManager
 func (a *Account) Save(secretsManager secrets.SecretsManager) (err error) {
 	var (
@@ -114,6 +79,10 @@ func (a *Account) GetEcdsaPrivateKey() (*ecdsa.PrivateKey, error) {
 	return AdaptECDSAPrivKey(a.Ecdsa)
 }
 
+func (a Account) Address() types.Address {
+	return types.Address(a.Ecdsa.Address())
+}
+
 // AdaptECDSAPrivKey converts ecdsa private key from wallet.Key to ecdsa.PrivateKey instance
 func AdaptECDSAPrivKey(ecdsaKey *wallet.Key) (*ecdsa.PrivateKey, error) {
 	ecdsaRaw, err := ecdsaKey.MarshallPrivateKey()
@@ -124,6 +93,37 @@ func AdaptECDSAPrivKey(ecdsaKey *wallet.Key) (*ecdsa.PrivateKey, error) {
 	return wallet.ParsePrivateKey(ecdsaRaw)
 }
 
-func (a Account) Address() types.Address {
-	return types.Address(a.Ecdsa.Address())
+// GetEcdsaFromSecret retrieves validator(ECDSA) key by using provided secretsManager
+func GetEcdsaFromSecret(secretsManager secrets.SecretsManager) (*wallet.Key, error) {
+	encodedKey, err := secretsManager.GetSecret(secrets.ValidatorKey)
+	if err != nil {
+		return nil, fmt.Errorf("failed to retrieve ecdsa key: %w", err)
+	}
+
+	ecdsaRaw, err := hex.DecodeString(string(encodedKey))
+	if err != nil {
+		return nil, fmt.Errorf("failed to retrieve ecdsa key: %w", err)
+	}
+
+	key, err := wallet.NewWalletFromPrivKey(ecdsaRaw)
+	if err != nil {
+		return nil, fmt.Errorf("failed to retrieve ecdsa key: %w", err)
+	}
+
+	return key, nil
+}
+
+// GetBlsFromSecret retrieves BLS key by using provided secretsManager
+func GetBlsFromSecret(secretsManager secrets.SecretsManager) (*bls.PrivateKey, error) {
+	encodedKey, err := secretsManager.GetSecret(secrets.ValidatorBLSKey)
+	if err != nil {
+		return nil, fmt.Errorf("failed to retrieve bls key: %w", err)
+	}
+
+	blsKey, err := bls.UnmarshalPrivateKey(encodedKey)
+	if err != nil {
+		return nil, fmt.Errorf("failed to retrieve bls key: %w", err)
+	}
+
+	return blsKey, nil
 }

jsonrpc/bridge_endpoint_test.go

@@ -6,11 +6,15 @@ import (
 
 	"github.com/hashicorp/go-hclog"
 	"github.com/stretchr/testify/require"
+	"github.com/umbracle/ethgo/wallet"
 )
 
 func TestBridgeEndpoint(t *testing.T) {
 	store := newMockStore()
 
+	privateKey, err := wallet.GenerateKey()
+	require.NoError(t, err)
+
 	dispatcher := newTestDispatcher(t,
 		hclog.NewNullLogger(),
 		store,
@@ -19,7 +23,7 @@ func TestBridgeEndpoint(t *testing.T) {
 			priceLimit:              0,
 			jsonRPCBatchLengthLimit: 20,
 			blockRangeLimit:         1000,
-			secretsManager:          setupSecretsManagerWithKey(t),
+			privateKey:              privateKey,
 		},
 	)
 

jsonrpc/dispatcher.go

@@ -11,11 +11,12 @@ import (
 	"time"
 	"unicode"
 
-	"github.com/0xPolygon/polygon-edge/crypto"
-	"github.com/0xPolygon/polygon-edge/secrets"
 	"github.com/armon/go-metrics"
 	"github.com/hashicorp/go-hclog"
 	jsonIter "github.com/json-iterator/go"
+	"github.com/umbracle/ethgo/wallet"
+
+	"github.com/0xPolygon/polygon-edge/crypto"
 )
 
 var (
@@ -68,8 +69,8 @@ type dispatcherParams struct {
 	blockRangeLimit         uint64
 	concurrentRequestsDebug uint64
 
-	secretsManager secrets.SecretsManager
-	txSigner       crypto.TxSigner
+	privateKey *wallet.Key
+	txSigner   crypto.TxSigner
 }
 
 func (dp dispatcherParams) isExceedingBatchLengthLimit(value uint64) bool {
@@ -101,18 +102,15 @@ func newDispatcher(
 func (d *Dispatcher) registerEndpoints(store JSONRPCStore) error {
 	var err error
 
-	d.endpoints.Eth, err = NewEth(
+	d.endpoints.Eth = NewEth(
 		d.logger,
 		store,
 		d.filterManager,
-		d.params.secretsManager,
+		d.params.privateKey,
 		d.params.chainID,
 		d.params.priceLimit,
 		d.params.txSigner,
 	)
-	if err != nil {
-		return err
-	}
 
 	d.endpoints.Net = &Net{
 		store,

jsonrpc/dispatcher_fuzz_test.go

@@ -8,11 +8,15 @@ import (
 	"github.com/hashicorp/go-hclog"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
+	"github.com/umbracle/ethgo/wallet"
 )
 
 func FuzzDispatcherFuncDecode(f *testing.F) {
 	srv := &mockService{msgCh: make(chan interface{}, 10)}
 
+	privKey, err := wallet.GenerateKey()
+	require.NoError(f, err)
+
 	dispatcher := newTestDispatcher(f,
 		hclog.NewNullLogger(),
 		newMockStore(),
@@ -21,7 +25,7 @@ func FuzzDispatcherFuncDecode(f *testing.F) {
 			priceLimit:              0,
 			jsonRPCBatchLengthLimit: 20,
 			blockRangeLimit:         1000,
-			secretsManager:          setupSecretsManagerWithKey(f),
+			privateKey:              privKey,
 		},
 	)
 
@@ -140,6 +144,9 @@ func FuzzDispatcherBatchRequest(f *testing.F) {
 	}
 
 	f.Fuzz(func(t *testing.T, batchLimit uint64, blockLimit uint64, params string) {
+		privateKey, err := wallet.GenerateKey()
+		require.NoError(t, err)
+
 		dispatcher := newTestDispatcher(t,
 			hclog.NewNullLogger(),
 			newMockStore(),
@@ -148,13 +155,13 @@ func FuzzDispatcherBatchRequest(f *testing.F) {
 				priceLimit:              0,
 				jsonRPCBatchLengthLimit: batchLimit,
 				blockRangeLimit:         blockLimit,
-				secretsManager:          setupSecretsManagerWithKey(t),
+				privateKey:              privateKey,
 			},
 		)
 
 		body := fmt.Sprintf(`[{"id":1,"jsonrpc":"2.0","method":"eth_getBlockByNumber","params": %s}]`, params)
 
-		_, err := dispatcher.HandleWs([]byte(body), mock)
+		_, err = dispatcher.HandleWs([]byte(body), mock)
 		assert.NoError(t, err)
 		_, err = dispatcher.Handle([]byte(body))
 		assert.NoError(t, err)
@@ -163,6 +170,10 @@ func FuzzDispatcherBatchRequest(f *testing.F) {
 
 func FuzzDispatcherWebsocketConnectionUnsubscribe(f *testing.F) {
 	store := newMockStore()
+
+	privateKey, err := wallet.GenerateKey()
+	require.NoError(f, err)
+
 	dispatcher := newTestDispatcher(f,
 		hclog.NewNullLogger(),
 		store,
@@ -171,7 +182,7 @@ func FuzzDispatcherWebsocketConnectionUnsubscribe(f *testing.F) {
 			priceLimit:              0,
 			jsonRPCBatchLengthLimit: 20,
 			blockRangeLimit:         1000,
-			secretsManager:          setupSecretsManagerWithKey(f),
+			privateKey:              privateKey,
 		},
 	)
 	mockConn := &mockWsConn{
@@ -202,6 +213,10 @@ func FuzzDispatcherWebsocketConnectionUnsubscribe(f *testing.F) {
 
 func FuzzDispatcherWebSocketConnectionRequestFormats(f *testing.F) {
 	store := newMockStore()
+
+	privateKey, err := wallet.GenerateKey()
+	require.NoError(f, err)
+
 	dispatcher := newTestDispatcher(f,
 		hclog.NewNullLogger(),
 		store,
@@ -210,7 +225,7 @@ func FuzzDispatcherWebSocketConnectionRequestFormats(f *testing.F) {
 			priceLimit:              0,
 			jsonRPCBatchLengthLimit: 20,
 			blockRangeLimit:         1000,
-			secretsManager:          setupSecretsManagerWithKey(f),
+			privateKey:              privateKey,
 		},
 	)
 	mockConnection, _ := newMockWsConnWithMsgCh()