status-im/status-go
2
0
Fork 0
mirror of https://github.com/status-im/status-go.git synced 2025-02-21 19:28:29 +00:00
Code Issues Projects Releases Wiki Activity

chore_: tests fix

Browse Source
This commit is contained in:
Dario Gabriel Lipicar 2025-02-04 11:44:18 -03:00 committed by dlipicar
parent 8c29a0cc1b
commit 3dfa6bd3fa
13 changed files with 194 additions and 203 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
api/backend_test.go
View File

@ -22,6 +22,7 @@ import (
gethcrypto "github.com/ethereum/go-ethereum/crypto" gethcrypto "github.com/ethereum/go-ethereum/crypto"
"github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/appdatabase" "github.com/status-im/status-go/appdatabase"
"github.com/status-im/status-go/connection" "github.com/status-im/status-go/connection"
"github.com/status-im/status-go/eth-node/crypto" "github.com/status-im/status-go/eth-node/crypto"
@ -1583,14 +1584,14 @@ func TestWalletConfigOnLoginAccount(t *testing.T) {
} }
require.Equal(t, b.config.WalletConfig.InfuraAPIKey, infuraToken) require.Equal(t, b.config.WalletConfig.InfuraAPIKey, infuraToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[MainnetChainID], alchemyEthereumMainnetToken) require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.MainnetChainID], alchemyEthereumMainnetToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[SepoliaChainID], alchemyEthereumSepoliaToken) require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.SepoliaChainID], alchemyEthereumSepoliaToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[ArbitrumChainID], alchemyArbitrumMainnetToken) require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.ArbitrumChainID], alchemyArbitrumMainnetToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[ArbitrumSepoliaChainID], alchemyArbitrumSepoliaToken) require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.ArbitrumSepoliaChainID], alchemyArbitrumSepoliaToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[OptimismChainID], alchemyOptimismMainnetToken) require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.OptimismChainID], alchemyOptimismMainnetToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[OptimismSepoliaChainID], alchemyOptimismSepoliaToken) require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.OptimismSepoliaChainID], alchemyOptimismSepoliaToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[BaseChainID], alchemyBaseMainnetToken) require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.BaseChainID], alchemyBaseMainnetToken)
require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[BaseSepoliaChainID], alchemyBaseSepoliaToken) require.Equal(t, b.config.WalletConfig.AlchemyAPIKeys[common.BaseSepoliaChainID], alchemyBaseSepoliaToken)
require.Equal(t, b.config.WalletConfig.RaribleMainnetAPIKey, raribleMainnetAPIKey) require.Equal(t, b.config.WalletConfig.RaribleMainnetAPIKey, raribleMainnetAPIKey)
require.Equal(t, b.config.WalletConfig.RaribleTestnetAPIKey, raribleTestnetAPIKey) require.Equal(t, b.config.WalletConfig.RaribleTestnetAPIKey, raribleTestnetAPIKey)

12
api/common/const.go Normal file
View File

@ -0,0 +1,12 @@
package common
const (
MainnetChainID uint64 = 1
SepoliaChainID uint64 = 11155111
OptimismChainID uint64 = 10
OptimismSepoliaChainID uint64 = 11155420
ArbitrumChainID uint64 = 42161
ArbitrumSepoliaChainID uint64 = 421614
BaseChainID uint64 = 8453
BaseSepoliaChainID uint64 = 84532
)

44
api/default_networks.go
View File

@ -4,23 +4,13 @@ import (
"fmt" "fmt"
"strings" "strings"
"github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/params" "github.com/status-im/status-go/params"
"github.com/status-im/status-go/params/networkhelper" "github.com/status-im/status-go/params/networkhelper"
"github.com/status-im/status-go/protocol/requests" "github.com/status-im/status-go/protocol/requests"
) )
const ( const (
MainnetChainID uint64 = 1
SepoliaChainID uint64 = 11155111
OptimismChainID uint64 = 10
OptimismSepoliaChainID uint64 = 11155420
ArbitrumChainID uint64 = 42161
ArbitrumSepoliaChainID uint64 = 421614
BaseChainID uint64 = 8453
BaseSepoliaChainID uint64 = 84532
sntSymbol = "SNT"
sttSymbol = "STT"
// Host suffixes for providers // Host suffixes for providers
SmartProxyHostSuffix = "eth-rpc.status.im" SmartProxyHostSuffix = "eth-rpc.status.im"
ProxyHostSuffix = "api.status.im" ProxyHostSuffix = "api.status.im"
@ -61,7 +51,7 @@ func smartProxyUrl(proxyHost, chainName, networkName string) string {
} }
func mainnet(proxyHost, stageName string) params.Network { func mainnet(proxyHost, stageName string) params.Network {
const chainID = MainnetChainID const chainID = common.MainnetChainID
const chainName = "ethereum" const chainName = "ethereum"
const networkName = "mainnet" const networkName = "mainnet"
@ -91,14 +81,14 @@ func mainnet(proxyHost, stageName string) params.Network {
IsTest: false, IsTest: false,
Layer: 1, Layer: 1,
Enabled: true, Enabled: true,
RelatedChainID: SepoliaChainID, RelatedChainID: common.SepoliaChainID,
IsActive: true, IsActive: true,
IsDeactivatable: false, IsDeactivatable: false,
} }
} }
func sepolia(proxyHost, stageName string) params.Network { func sepolia(proxyHost, stageName string) params.Network {
const chainID = SepoliaChainID const chainID = common.SepoliaChainID
const chainName = "ethereum" const chainName = "ethereum"
const networkName = "sepolia" const networkName = "sepolia"
@ -128,14 +118,14 @@ func sepolia(proxyHost, stageName string) params.Network {
IsTest: true, IsTest: true,
Layer: 1, Layer: 1,
Enabled: true, Enabled: true,
RelatedChainID: MainnetChainID, RelatedChainID: common.MainnetChainID,
IsActive: true, IsActive: true,
IsDeactivatable: false, IsDeactivatable: false,
} }
} }
func optimism(proxyHost, stageName string) params.Network { func optimism(proxyHost, stageName string) params.Network {
const chainID = OptimismChainID const chainID = common.OptimismChainID
const chainName = "optimism" const chainName = "optimism"
const networkName = "mainnet" const networkName = "mainnet"
@ -165,14 +155,14 @@ func optimism(proxyHost, stageName string) params.Network {
IsTest: false, IsTest: false,
Layer: 2, Layer: 2,
Enabled: true, Enabled: true,
RelatedChainID: OptimismSepoliaChainID, RelatedChainID: common.OptimismSepoliaChainID,
IsActive: true, IsActive: true,
IsDeactivatable: true, IsDeactivatable: true,
} }
} }
func optimismSepolia(proxyHost, stageName string) params.Network { func optimismSepolia(proxyHost, stageName string) params.Network {
const chainID = OptimismSepoliaChainID const chainID = common.OptimismSepoliaChainID
const chainName = "optimism" const chainName = "optimism"
const networkName = "sepolia" const networkName = "sepolia"
@ -202,14 +192,14 @@ func optimismSepolia(proxyHost, stageName string) params.Network {
IsTest: true, IsTest: true,
Layer: 2, Layer: 2,
Enabled: false, Enabled: false,
RelatedChainID: OptimismChainID, RelatedChainID: common.OptimismChainID,
IsActive: true, IsActive: true,
IsDeactivatable: true, IsDeactivatable: true,
} }
} }
func arbitrum(proxyHost, stageName string) params.Network { func arbitrum(proxyHost, stageName string) params.Network {
const chainID = ArbitrumChainID const chainID = common.ArbitrumChainID
const chainName = "arbitrum" const chainName = "arbitrum"
const networkName = "mainnet" const networkName = "mainnet"
@ -239,14 +229,14 @@ func arbitrum(proxyHost, stageName string) params.Network {
IsTest: false, IsTest: false,
Layer: 2, Layer: 2,
Enabled: true, Enabled: true,
RelatedChainID: ArbitrumSepoliaChainID, RelatedChainID: common.ArbitrumSepoliaChainID,
IsActive: true, IsActive: true,
IsDeactivatable: true, IsDeactivatable: true,
} }
} }
func arbitrumSepolia(proxyHost, stageName string) params.Network { func arbitrumSepolia(proxyHost, stageName string) params.Network {
const chainID = ArbitrumSepoliaChainID const chainID = common.ArbitrumSepoliaChainID
const chainName = "arbitrum" const chainName = "arbitrum"
const networkName = "sepolia" const networkName = "sepolia"
@ -276,14 +266,14 @@ func arbitrumSepolia(proxyHost, stageName string) params.Network {
IsTest: true, IsTest: true,
Layer: 2, Layer: 2,
Enabled: false, Enabled: false,
RelatedChainID: ArbitrumChainID, RelatedChainID: common.ArbitrumChainID,
IsActive: true, IsActive: true,
IsDeactivatable: true, IsDeactivatable: true,
} }
} }
func base(proxyHost, stageName string) params.Network { func base(proxyHost, stageName string) params.Network {
const chainID = BaseChainID const chainID = common.BaseChainID
const chainName = "base" const chainName = "base"
const networkName = "mainnet" const networkName = "mainnet"
@ -313,14 +303,14 @@ func base(proxyHost, stageName string) params.Network {
IsTest: false, IsTest: false,
Layer: 2, Layer: 2,
Enabled: true, Enabled: true,
RelatedChainID: BaseSepoliaChainID, RelatedChainID: common.BaseSepoliaChainID,
IsActive: true, IsActive: true,
IsDeactivatable: true, IsDeactivatable: true,
} }
} }
func baseSepolia(proxyHost, stageName string) params.Network { func baseSepolia(proxyHost, stageName string) params.Network {
const chainID = BaseSepoliaChainID const chainID = common.BaseSepoliaChainID
const chainName = "base" const chainName = "base"
const networkName = "sepolia" const networkName = "sepolia"
@ -350,7 +340,7 @@ func baseSepolia(proxyHost, stageName string) params.Network {
IsTest: true, IsTest: true,
Layer: 2, Layer: 2,
Enabled: false, Enabled: false,
RelatedChainID: BaseChainID, RelatedChainID: common.BaseChainID,
IsActive: true, IsActive: true,
IsDeactivatable: true, IsDeactivatable: true,
} }

17
api/default_networks_test.go
View File

@ -4,6 +4,7 @@ import (
"strings" "strings"
"testing" "testing"
"github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/params" "github.com/status-im/status-go/params"
"github.com/pkg/errors" "github.com/pkg/errors"
@ -30,14 +31,14 @@ func TestBuildDefaultNetworks(t *testing.T) {
for _, n := range actualNetworks { for _, n := range actualNetworks {
var err error var err error
switch n.ChainID { switch n.ChainID {
case MainnetChainID: case common.MainnetChainID:
case SepoliaChainID: case common.SepoliaChainID:
case OptimismChainID: case common.OptimismChainID:
case OptimismSepoliaChainID: case common.OptimismSepoliaChainID:
case ArbitrumChainID: case common.ArbitrumChainID:
case ArbitrumSepoliaChainID: case common.ArbitrumSepoliaChainID:
case BaseChainID: case common.BaseChainID:
case BaseSepoliaChainID: case common.BaseSepoliaChainID:
default: default:
err = errors.Errorf("unexpected chain id: %d", n.ChainID) err = errors.Errorf("unexpected chain id: %d", n.ChainID)
} }

17
api/defaults.go
View File

@ -7,6 +7,7 @@ import (
"path/filepath" "path/filepath"
"github.com/status-im/status-go/account/generator" "github.com/status-im/status-go/account/generator"
"github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/eth-node/types"
"github.com/status-im/status-go/multiaccounts/settings" "github.com/status-im/status-go/multiaccounts/settings"
"github.com/status-im/status-go/params" "github.com/status-im/status-go/params"
@ -199,28 +200,28 @@ func buildWalletConfig(request *requests.WalletSecretsConfig, statusProxyEnabled
} }
if request.AlchemyEthereumMainnetToken != "" { if request.AlchemyEthereumMainnetToken != "" {
walletConfig.AlchemyAPIKeys[MainnetChainID] = request.AlchemyEthereumMainnetToken walletConfig.AlchemyAPIKeys[common.MainnetChainID] = request.AlchemyEthereumMainnetToken
} }
if request.AlchemyEthereumSepoliaToken != "" { if request.AlchemyEthereumSepoliaToken != "" {
walletConfig.AlchemyAPIKeys[SepoliaChainID] = request.AlchemyEthereumSepoliaToken walletConfig.AlchemyAPIKeys[common.SepoliaChainID] = request.AlchemyEthereumSepoliaToken
} }
if request.AlchemyArbitrumMainnetToken != "" { if request.AlchemyArbitrumMainnetToken != "" {
walletConfig.AlchemyAPIKeys[ArbitrumChainID] = request.AlchemyArbitrumMainnetToken walletConfig.AlchemyAPIKeys[common.ArbitrumChainID] = request.AlchemyArbitrumMainnetToken
} }
if request.AlchemyArbitrumSepoliaToken != "" { if request.AlchemyArbitrumSepoliaToken != "" {
walletConfig.AlchemyAPIKeys[ArbitrumSepoliaChainID] = request.AlchemyArbitrumSepoliaToken walletConfig.AlchemyAPIKeys[common.ArbitrumSepoliaChainID] = request.AlchemyArbitrumSepoliaToken
} }
if request.AlchemyOptimismMainnetToken != "" { if request.AlchemyOptimismMainnetToken != "" {
walletConfig.AlchemyAPIKeys[OptimismChainID] = request.AlchemyOptimismMainnetToken walletConfig.AlchemyAPIKeys[common.OptimismChainID] = request.AlchemyOptimismMainnetToken
} }
if request.AlchemyOptimismSepoliaToken != "" { if request.AlchemyOptimismSepoliaToken != "" {
walletConfig.AlchemyAPIKeys[OptimismSepoliaChainID] = request.AlchemyOptimismSepoliaToken walletConfig.AlchemyAPIKeys[common.OptimismSepoliaChainID] = request.AlchemyOptimismSepoliaToken
} }
if request.AlchemyBaseMainnetToken != "" { if request.AlchemyBaseMainnetToken != "" {
walletConfig.AlchemyAPIKeys[BaseChainID] = request.AlchemyBaseMainnetToken walletConfig.AlchemyAPIKeys[common.BaseChainID] = request.AlchemyBaseMainnetToken
} }
if request.AlchemyBaseSepoliaToken != "" { if request.AlchemyBaseSepoliaToken != "" {
walletConfig.AlchemyAPIKeys[BaseSepoliaChainID] = request.AlchemyBaseSepoliaToken walletConfig.AlchemyAPIKeys[common.BaseSepoliaChainID] = request.AlchemyBaseSepoliaToken
} }
if request.StatusProxyMarketUser != "" { if request.StatusProxyMarketUser != "" {
walletConfig.StatusProxyMarketUser = request.StatusProxyMarketUser walletConfig.StatusProxyMarketUser = request.StatusProxyMarketUser

38
params/networkhelper/provider_utils_test.go
View File

@ -11,7 +11,7 @@ import (
"github.com/stretchr/testify/assert" "github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/status-im/status-go/api" api_common "github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/params" "github.com/status-im/status-go/params"
"github.com/status-im/status-go/params/networkhelper" "github.com/status-im/status-go/params/networkhelper"
"github.com/status-im/status-go/rpc/network/testutil" "github.com/status-im/status-go/rpc/network/testutil"
@ -58,15 +58,15 @@ func TestMergeProvidersPreserveEnabledAndOrder(t *testing.T) {
func TestOverrideBasicAuth(t *testing.T) { func TestOverrideBasicAuth(t *testing.T) {
// Arrange: Create a sample list of networks with various provider types // Arrange: Create a sample list of networks with various provider types
networks := []params.Network{ networks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{ *testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
*params.NewUserProvider(api.MainnetChainID, "Provider1", "https://userprovider.example.com", true), *params.NewUserProvider(api_common.MainnetChainID, "Provider1", "https://userprovider.example.com", true),
*params.NewProxyProvider(api.MainnetChainID, "Provider2", "https://proxyprovider.example.com", true), *params.NewProxyProvider(api_common.MainnetChainID, "Provider2", "https://proxyprovider.example.com", true),
*params.NewEthRpcProxyProvider(api.MainnetChainID, "Provider3", "https://ethrpcproxy.example.com", true), *params.NewEthRpcProxyProvider(api_common.MainnetChainID, "Provider3", "https://ethrpcproxy.example.com", true),
}), }),
*testutil.CreateNetwork(api.OptimismChainID, "Optimism", []params.RpcProvider{ *testutil.CreateNetwork(api_common.OptimismChainID, "Optimism", []params.RpcProvider{
*params.NewDirectProvider(api.OptimismChainID, "Provider4", "https://directprovider.example.com", true), *params.NewDirectProvider(api_common.OptimismChainID, "Provider4", "https://directprovider.example.com", true),
*params.NewProxyProvider(api.OptimismChainID, "Provider5", "https://proxyprovider2.example.com", true), *params.NewProxyProvider(api_common.OptimismChainID, "Provider5", "https://proxyprovider2.example.com", true),
*params.NewEthRpcProxyProvider(api.OptimismChainID, "Provider6", "https://ethrpcproxy2.example.com", true), *params.NewEthRpcProxyProvider(api_common.OptimismChainID, "Provider6", "https://ethrpcproxy2.example.com", true),
}), }),
} }
networks[0].RpcProviders[1].Enabled = false networks[0].RpcProviders[1].Enabled = false
@ -131,14 +131,14 @@ func TestOverrideBasicAuth(t *testing.T) {
func TestOverrideDirectProvidersAuth(t *testing.T) { func TestOverrideDirectProvidersAuth(t *testing.T) {
// Create a sample list of networks with various provider types // Create a sample list of networks with various provider types
networks := []params.Network{ networks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{ *testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
*params.NewUserProvider(api.MainnetChainID, "Provider1", "https://user.example.com/", true), *params.NewUserProvider(api_common.MainnetChainID, "Provider1", "https://user.example.com/", true),
*params.NewDirectProvider(api.MainnetChainID, "Provider2", "https://mainnet.infura.io/v3/", true), *params.NewDirectProvider(api_common.MainnetChainID, "Provider2", "https://mainnet.infura.io/v3/", true),
*params.NewDirectProvider(api.MainnetChainID, "Provider3", "https://eth-archival.rpc.grove.city/v1/", true), *params.NewDirectProvider(api_common.MainnetChainID, "Provider3", "https://eth-archival.rpc.grove.city/v1/", true),
}), }),
*testutil.CreateNetwork(api.OptimismChainID, "Optimism", []params.RpcProvider{ *testutil.CreateNetwork(api_common.OptimismChainID, "Optimism", []params.RpcProvider{
*params.NewDirectProvider(api.OptimismChainID, "Provider4", "https://optimism.infura.io/v3/", true), *params.NewDirectProvider(api_common.OptimismChainID, "Provider4", "https://optimism.infura.io/v3/", true),
*params.NewDirectProvider(api.OptimismChainID, "Provider5", "https://op.grove.city/v1/", true), *params.NewDirectProvider(api_common.OptimismChainID, "Provider5", "https://op.grove.city/v1/", true),
}), }),
} }
@ -175,9 +175,9 @@ func TestOverrideDirectProvidersAuth(t *testing.T) {
} }
func TestDeepCopyNetwork(t *testing.T) { func TestDeepCopyNetwork(t *testing.T) {
originalNetwork := testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{ originalNetwork := testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
*params.NewUserProvider(api.MainnetChainID, "Provider1", "https://userprovider.example.com", true), *params.NewUserProvider(api_common.MainnetChainID, "Provider1", "https://userprovider.example.com", true),
*params.NewDirectProvider(api.MainnetChainID, "Provider2", "https://mainnet.infura.io/v3/", true), *params.NewDirectProvider(api_common.MainnetChainID, "Provider2", "https://mainnet.infura.io/v3/", true),
}) })
originalNetwork.TokenOverrides = []params.TokenOverride{ originalNetwork.TokenOverrides = []params.TokenOverride{

38
rpc/network/db/network_db_test.go
View File

@ -7,7 +7,7 @@ import (
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite" "github.com/stretchr/testify/suite"
"github.com/status-im/status-go/api" api_common "github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/appdatabase" "github.com/status-im/status-go/appdatabase"
"github.com/status-im/status-go/params" "github.com/status-im/status-go/params"
"github.com/status-im/status-go/rpc/network/db" "github.com/status-im/status-go/rpc/network/db"
@ -98,15 +98,15 @@ func (s *NetworksPersistenceTestSuite) verifyNetworkDeletion(chainID uint64) {
// Tests // Tests
func (s *NetworksPersistenceTestSuite) TestAddAndGetNetworkWithProviders() { func (s *NetworksPersistenceTestSuite) TestAddAndGetNetworkWithProviders() {
network := testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", []params.RpcProvider{ network := testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", []params.RpcProvider{
testutil.CreateProvider(api.OptimismChainID, "Provider1", params.UserProviderType, true, "https://rpc.optimism.io"), testutil.CreateProvider(api_common.OptimismChainID, "Provider1", params.UserProviderType, true, "https://rpc.optimism.io"),
testutil.CreateProvider(api.OptimismChainID, "Provider2", params.EmbeddedProxyProviderType, false, "https://backup.optimism.io"), testutil.CreateProvider(api_common.OptimismChainID, "Provider2", params.EmbeddedProxyProviderType, false, "https://backup.optimism.io"),
}) })
s.addAndVerifyNetworks([]*params.Network{network}) s.addAndVerifyNetworks([]*params.Network{network})
} }
func (s *NetworksPersistenceTestSuite) TestDeleteNetworkWithProviders() { func (s *NetworksPersistenceTestSuite) TestDeleteNetworkWithProviders() {
network := testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", DefaultProviders(api.OptimismChainID)) network := testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", DefaultProviders(api_common.OptimismChainID))
s.addAndVerifyNetworks([]*params.Network{network}) s.addAndVerifyNetworks([]*params.Network{network})
err := s.networksPersistence.DeleteNetwork(network.ChainID) err := s.networksPersistence.DeleteNetwork(network.ChainID)
@ -116,13 +116,13 @@ func (s *NetworksPersistenceTestSuite) TestDeleteNetworkWithProviders() {
} }
func (s *NetworksPersistenceTestSuite) TestUpdateNetworkAndProviders() { func (s *NetworksPersistenceTestSuite) TestUpdateNetworkAndProviders() {
network := testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", DefaultProviders(api.OptimismChainID)) network := testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", DefaultProviders(api_common.OptimismChainID))
s.addAndVerifyNetworks([]*params.Network{network}) s.addAndVerifyNetworks([]*params.Network{network})
// Update fields // Update fields
network.ChainName = "Updated Optimism Mainnet" network.ChainName = "Updated Optimism Mainnet"
network.RpcProviders = []params.RpcProvider{ network.RpcProviders = []params.RpcProvider{
testutil.CreateProvider(api.OptimismChainID, "UpdatedProvider", params.UserProviderType, true, "https://rpc.optimism.updated.io"), testutil.CreateProvider(api_common.OptimismChainID, "UpdatedProvider", params.UserProviderType, true, "https://rpc.optimism.updated.io"),
} }
s.addAndVerifyNetworks([]*params.Network{network}) s.addAndVerifyNetworks([]*params.Network{network})
@ -130,8 +130,8 @@ func (s *NetworksPersistenceTestSuite) TestUpdateNetworkAndProviders() {
func (s *NetworksPersistenceTestSuite) TestDeleteAllNetworks() { func (s *NetworksPersistenceTestSuite) TestDeleteAllNetworks() {
networks := []*params.Network{ networks := []*params.Network{
testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", DefaultProviders(api.MainnetChainID)), testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", DefaultProviders(api_common.MainnetChainID)),
testutil.CreateNetwork(api.SepoliaChainID, "Sepolia Testnet", DefaultProviders(api.SepoliaChainID)), testutil.CreateNetwork(api_common.SepoliaChainID, "Sepolia Testnet", DefaultProviders(api_common.SepoliaChainID)),
} }
s.addAndVerifyNetworks(networks) s.addAndVerifyNetworks(networks)
@ -145,11 +145,11 @@ func (s *NetworksPersistenceTestSuite) TestDeleteAllNetworks() {
func (s *NetworksPersistenceTestSuite) TestSetNetworks() { func (s *NetworksPersistenceTestSuite) TestSetNetworks() {
initialNetworks := []*params.Network{ initialNetworks := []*params.Network{
testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", DefaultProviders(api.MainnetChainID)), testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", DefaultProviders(api_common.MainnetChainID)),
testutil.CreateNetwork(api.SepoliaChainID, "Sepolia Testnet", DefaultProviders(api.SepoliaChainID)), testutil.CreateNetwork(api_common.SepoliaChainID, "Sepolia Testnet", DefaultProviders(api_common.SepoliaChainID)),
} }
newNetworks := []*params.Network{ newNetworks := []*params.Network{
testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", DefaultProviders(api.OptimismChainID)), testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", DefaultProviders(api_common.OptimismChainID)),
} }
// Add initial networks // Add initial networks
@ -159,25 +159,25 @@ func (s *NetworksPersistenceTestSuite) TestSetNetworks() {
s.addAndVerifyNetworks(newNetworks) s.addAndVerifyNetworks(newNetworks)
// Verify old networks are removed // Verify old networks are removed
s.verifyNetworkDeletion(api.MainnetChainID) s.verifyNetworkDeletion(api_common.MainnetChainID)
s.verifyNetworkDeletion(api.SepoliaChainID) s.verifyNetworkDeletion(api_common.SepoliaChainID)
} }
func (s *NetworksPersistenceTestSuite) TestValidationForNetworksAndProviders() { func (s *NetworksPersistenceTestSuite) TestValidationForNetworksAndProviders() {
// Invalid Network: Missing required ChainName // Invalid Network: Missing required ChainName
invalidNetwork := testutil.CreateNetwork(api.MainnetChainID, "", DefaultProviders(api.MainnetChainID)) invalidNetwork := testutil.CreateNetwork(api_common.MainnetChainID, "", DefaultProviders(api_common.MainnetChainID))
// Invalid Provider: Missing URL // Invalid Provider: Missing URL
invalidProvider := params.RpcProvider{ invalidProvider := params.RpcProvider{
Name: "InvalidProvider", Name: "InvalidProvider",
ChainID: api.MainnetChainID, ChainID: api_common.MainnetChainID,
URL: "", // Invalid URL: "", // Invalid
Type: params.UserProviderType, Type: params.UserProviderType,
Enabled: true, Enabled: true,
} }
// Add invalid provider to a valid network // Add invalid provider to a valid network
validNetworkWithInvalidProvider := testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", []params.RpcProvider{invalidProvider}) validNetworkWithInvalidProvider := testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", []params.RpcProvider{invalidProvider})
// Invalid networks and providers should fail validation // Invalid networks and providers should fail validation
networksToValidate := []*params.Network{ networksToValidate := []*params.Network{
@ -197,7 +197,7 @@ func (s *NetworksPersistenceTestSuite) TestValidationForNetworksAndProviders() {
} }
func (s *NetworksPersistenceTestSuite) TestSetActive() { func (s *NetworksPersistenceTestSuite) TestSetActive() {
network := testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", DefaultProviders(api.OptimismChainID)) network := testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", DefaultProviders(api_common.OptimismChainID))
s.addAndVerifyNetworks([]*params.Network{network}) s.addAndVerifyNetworks([]*params.Network{network})
// Deactivate the network // Deactivate the network
@ -222,7 +222,7 @@ func (s *NetworksPersistenceTestSuite) TestSetActive() {
} }
func (s *NetworksPersistenceTestSuite) TestSetEnabled() { func (s *NetworksPersistenceTestSuite) TestSetEnabled() {
network := testutil.CreateNetwork(api.OptimismChainID, "Optimism Mainnet", DefaultProviders(api.OptimismChainID)) network := testutil.CreateNetwork(api_common.OptimismChainID, "Optimism Mainnet", DefaultProviders(api_common.OptimismChainID))
s.addAndVerifyNetworks([]*params.Network{network}) s.addAndVerifyNetworks([]*params.Network{network})
// Disable the network // Disable the network

44
rpc/network/db/rpc_provider_db_test.go
View File

@ -7,7 +7,7 @@ import (
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite" "github.com/stretchr/testify/suite"
"github.com/status-im/status-go/api" api_common "github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/appdatabase" "github.com/status-im/status-go/appdatabase"
"github.com/status-im/status-go/params" "github.com/status-im/status-go/params"
"github.com/status-im/status-go/rpc/network/db" "github.com/status-im/status-go/rpc/network/db"
@ -41,23 +41,23 @@ func TestRpcProviderPersistenceTestSuite(t *testing.T) {
// Test cases // Test cases
func (s *RpcProviderPersistenceTestSuite) TestAddAndGetRpcProvider() { func (s *RpcProviderPersistenceTestSuite) TestAddAndGetRpcProvider() {
provider := testutil.CreateProvider(api.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com") provider := testutil.CreateProvider(api_common.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com")
err := s.rpcPersistence.AddRpcProvider(provider) err := s.rpcPersistence.AddRpcProvider(provider)
s.Require().NoError(err) s.Require().NoError(err)
// Verify the added provider // Verify the added provider
providers, err := s.rpcPersistence.GetRpcProviders(api.MainnetChainID) providers, err := s.rpcPersistence.GetRpcProviders(api_common.MainnetChainID)
s.Require().NoError(err) s.Require().NoError(err)
testutil.CompareProvidersList(s.T(), []params.RpcProvider{provider}, providers) testutil.CompareProvidersList(s.T(), []params.RpcProvider{provider}, providers)
} }
func (s *RpcProviderPersistenceTestSuite) TestGetRpcProvidersByType() { func (s *RpcProviderPersistenceTestSuite) TestGetRpcProvidersByType() {
providers := []params.RpcProvider{ providers := []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "UserProvider1", params.UserProviderType, true, "https://provider1.example.com"), testutil.CreateProvider(api_common.MainnetChainID, "UserProvider1", params.UserProviderType, true, "https://provider1.example.com"),
testutil.CreateProvider(api.MainnetChainID, "EmbeddedDirect1", params.EmbeddedDirectProviderType, false, "https://provider2.example.com"), testutil.CreateProvider(api_common.MainnetChainID, "EmbeddedDirect1", params.EmbeddedDirectProviderType, false, "https://provider2.example.com"),
testutil.CreateProvider(api.MainnetChainID, "UserProvider2", params.UserProviderType, false, "https://provider3.example.com"), testutil.CreateProvider(api_common.MainnetChainID, "UserProvider2", params.UserProviderType, false, "https://provider3.example.com"),
testutil.CreateProvider(api.MainnetChainID, "EmbeddedProxy1", params.EmbeddedProxyProviderType, true, "https://provider4.example.com"), testutil.CreateProvider(api_common.MainnetChainID, "EmbeddedProxy1", params.EmbeddedProxyProviderType, true, "https://provider4.example.com"),
} }
for _, provider := range providers { for _, provider := range providers {
@ -66,42 +66,42 @@ func (s *RpcProviderPersistenceTestSuite) TestGetRpcProvidersByType() {
} }
// Verify by type // Verify by type
userProviders, err := s.rpcPersistence.GetRpcProvidersByType(api.MainnetChainID, params.UserProviderType) userProviders, err := s.rpcPersistence.GetRpcProvidersByType(api_common.MainnetChainID, params.UserProviderType)
s.Require().NoError(err) s.Require().NoError(err)
testutil.CompareProvidersList(s.T(), []params.RpcProvider{providers[0], providers[2]}, userProviders) testutil.CompareProvidersList(s.T(), []params.RpcProvider{providers[0], providers[2]}, userProviders)
embeddedDirectProviders, err := s.rpcPersistence.GetRpcProvidersByType(api.MainnetChainID, params.EmbeddedDirectProviderType) embeddedDirectProviders, err := s.rpcPersistence.GetRpcProvidersByType(api_common.MainnetChainID, params.EmbeddedDirectProviderType)
s.Require().NoError(err) s.Require().NoError(err)
testutil.CompareProvidersList(s.T(), []params.RpcProvider{providers[1]}, embeddedDirectProviders) testutil.CompareProvidersList(s.T(), []params.RpcProvider{providers[1]}, embeddedDirectProviders)
embeddedProxyProviders, err := s.rpcPersistence.GetRpcProvidersByType(api.MainnetChainID, params.EmbeddedProxyProviderType) embeddedProxyProviders, err := s.rpcPersistence.GetRpcProvidersByType(api_common.MainnetChainID, params.EmbeddedProxyProviderType)
s.Require().NoError(err) s.Require().NoError(err)
testutil.CompareProvidersList(s.T(), []params.RpcProvider{providers[3]}, embeddedProxyProviders) testutil.CompareProvidersList(s.T(), []params.RpcProvider{providers[3]}, embeddedProxyProviders)
} }
func (s *RpcProviderPersistenceTestSuite) TestDeleteRpcProviders() { func (s *RpcProviderPersistenceTestSuite) TestDeleteRpcProviders() {
provider := testutil.CreateProvider(api.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com") provider := testutil.CreateProvider(api_common.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com")
err := s.rpcPersistence.AddRpcProvider(provider) err := s.rpcPersistence.AddRpcProvider(provider)
s.Require().NoError(err) s.Require().NoError(err)
err = s.rpcPersistence.DeleteRpcProviders(api.MainnetChainID) err = s.rpcPersistence.DeleteRpcProviders(api_common.MainnetChainID)
s.Require().NoError(err) s.Require().NoError(err)
// Verify deletion // Verify deletion
providers, err := s.rpcPersistence.GetRpcProviders(api.MainnetChainID) providers, err := s.rpcPersistence.GetRpcProviders(api_common.MainnetChainID)
s.Require().NoError(err) s.Require().NoError(err)
s.Require().Empty(providers) s.Require().Empty(providers)
} }
func (s *RpcProviderPersistenceTestSuite) TestUpdateRpcProvider() { func (s *RpcProviderPersistenceTestSuite) TestUpdateRpcProvider() {
provider := testutil.CreateProvider(api.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com") provider := testutil.CreateProvider(api_common.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com")
err := s.rpcPersistence.AddRpcProvider(provider) err := s.rpcPersistence.AddRpcProvider(provider)
s.Require().NoError(err) s.Require().NoError(err)
// Retrieve provider to get the ID // Retrieve provider to get the ID
providers, err := s.rpcPersistence.GetRpcProviders(api.MainnetChainID) providers, err := s.rpcPersistence.GetRpcProviders(api_common.MainnetChainID)
s.Require().NoError(err) s.Require().NoError(err)
s.Require().Len(providers, 1) s.Require().Len(providers, 1)
@ -113,15 +113,15 @@ func (s *RpcProviderPersistenceTestSuite) TestUpdateRpcProvider() {
s.Require().NoError(err) s.Require().NoError(err)
// Verify update // Verify update
updatedProviders, err := s.rpcPersistence.GetRpcProviders(api.MainnetChainID) updatedProviders, err := s.rpcPersistence.GetRpcProviders(api_common.MainnetChainID)
s.Require().NoError(err) s.Require().NoError(err)
testutil.CompareProvidersList(s.T(), []params.RpcProvider{provider}, updatedProviders) testutil.CompareProvidersList(s.T(), []params.RpcProvider{provider}, updatedProviders)
} }
func (s *RpcProviderPersistenceTestSuite) TestSetRpcProviders() { func (s *RpcProviderPersistenceTestSuite) TestSetRpcProviders() {
initialProviders := []params.RpcProvider{ initialProviders := []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com"), testutil.CreateProvider(api_common.MainnetChainID, "Provider1", params.UserProviderType, true, "https://provider1.example.com"),
testutil.CreateProvider(api.MainnetChainID, "Provider2", params.EmbeddedDirectProviderType, false, "https://provider2.example.com"), testutil.CreateProvider(api_common.MainnetChainID, "Provider2", params.EmbeddedDirectProviderType, false, "https://provider2.example.com"),
} }
for _, provider := range initialProviders { for _, provider := range initialProviders {
@ -130,15 +130,15 @@ func (s *RpcProviderPersistenceTestSuite) TestSetRpcProviders() {
} }
newProviders := []params.RpcProvider{ newProviders := []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "NewProvider1", params.UserProviderType, true, "https://newprovider1.example.com"), testutil.CreateProvider(api_common.MainnetChainID, "NewProvider1", params.UserProviderType, true, "https://newprovider1.example.com"),
testutil.CreateProvider(api.MainnetChainID, "NewProvider2", params.EmbeddedProxyProviderType, true, "https://newprovider2.example.com"), testutil.CreateProvider(api_common.MainnetChainID, "NewProvider2", params.EmbeddedProxyProviderType, true, "https://newprovider2.example.com"),
} }
err := s.rpcPersistence.SetRpcProviders(api.MainnetChainID, newProviders) err := s.rpcPersistence.SetRpcProviders(api_common.MainnetChainID, newProviders)
s.Require().NoError(err) s.Require().NoError(err)
// Verify replacement // Verify replacement
providers, err := s.rpcPersistence.GetRpcProviders(api.MainnetChainID) providers, err := s.rpcPersistence.GetRpcProviders(api_common.MainnetChainID)
s.Require().NoError(err) s.Require().NoError(err)
testutil.CompareProvidersList(s.T(), newProviders, providers) testutil.CompareProvidersList(s.T(), newProviders, providers)
} }

105
rpc/network/network_test.go
View File

@ -4,8 +4,7 @@ import (
"database/sql" "database/sql"
"testing" "testing"
"github.com/status-im/status-go/api" api_common "github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/appdatabase" "github.com/status-im/status-go/appdatabase"
"github.com/status-im/status-go/params" "github.com/status-im/status-go/params"
"github.com/status-im/status-go/params/networkhelper" "github.com/status-im/status-go/params/networkhelper"
@ -35,23 +34,23 @@ func (s *NetworkManagerTestSuite) SetupTest() {
// Use testutil to initialize networks // Use testutil to initialize networks
initNetworks := []params.Network{ initNetworks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{ *testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "Infura Mainnet", params.UserProviderType, true, "https://mainnet.infura.io"), testutil.CreateProvider(api_common.MainnetChainID, "Infura Mainnet", params.UserProviderType, true, "https://mainnet.infura.io"),
}), }),
*testutil.CreateNetwork(api.SepoliaChainID, "Sepolia Testnet", []params.RpcProvider{ *testutil.CreateNetwork(api_common.SepoliaChainID, "Sepolia Testnet", []params.RpcProvider{
testutil.CreateProvider(api.SepoliaChainID, "Infura Sepolia", params.UserProviderType, true, "https://sepolia.infura.io"), testutil.CreateProvider(api_common.SepoliaChainID, "Infura Sepolia", params.UserProviderType, true, "https://sepolia.infura.io"),
}), }),
*testutil.CreateNetwork(api.OptimismChainID, "Optimistic Ethereum", []params.RpcProvider{ *testutil.CreateNetwork(api_common.OptimismChainID, "Optimistic Ethereum", []params.RpcProvider{
testutil.CreateProvider(api.OptimismChainID, "Infura Optimism", params.UserProviderType, true, "https://optimism.infura.io"), testutil.CreateProvider(api_common.OptimismChainID, "Infura Optimism", params.UserProviderType, true, "https://optimism.infura.io"),
}), }),
*testutil.CreateNetwork(api.OptimismSepoliaChainID, "Optimistic Sepolia", []params.RpcProvider{ *testutil.CreateNetwork(api_common.OptimismSepoliaChainID, "Optimistic Sepolia", []params.RpcProvider{
testutil.CreateProvider(api.OptimismSepoliaChainID, "Infura Optimism Sepolia", params.UserProviderType, true, "https://optimism-sepolia.infura.io"), testutil.CreateProvider(api_common.OptimismSepoliaChainID, "Infura Optimism Sepolia", params.UserProviderType, true, "https://optimism-sepolia.infura.io"),
}), }),
*testutil.CreateNetwork(api.BaseChainID, "Base", []params.RpcProvider{ *testutil.CreateNetwork(api_common.BaseChainID, "Base", []params.RpcProvider{
testutil.CreateProvider(api.BaseChainID, "Infura Base", params.UserProviderType, true, "https://base.infura.io"), testutil.CreateProvider(api_common.BaseChainID, "Infura Base", params.UserProviderType, true, "https://base.infura.io"),
}), }),
*testutil.CreateNetwork(api.BaseSepoliaChainID, "Base Sepolia", []params.RpcProvider{ *testutil.CreateNetwork(api_common.BaseSepoliaChainID, "Base Sepolia", []params.RpcProvider{
testutil.CreateProvider(api.BaseSepoliaChainID, "Infura Base Sepolia", params.UserProviderType, true, "https://base-sepolia.infura.io"), testutil.CreateProvider(api_common.BaseSepoliaChainID, "Infura Base Sepolia", params.UserProviderType, true, "https://base-sepolia.infura.io"),
}), }),
} }
// Make "Ethereum Mainnet" network not deactivatable // Make "Ethereum Mainnet" network not deactivatable
@ -92,14 +91,14 @@ func (s *NetworkManagerTestSuite) assertDbNetworks(expectedNetworks []params.Net
func (s *NetworkManagerTestSuite) TestUserAddsCustomProviders() { func (s *NetworkManagerTestSuite) TestUserAddsCustomProviders() {
// Adding custom providers // Adding custom providers
customProviders := []params.RpcProvider{ customProviders := []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "CustomProvider1", params.UserProviderType, true, "https://custom1.example.com"), testutil.CreateProvider(api_common.MainnetChainID, "CustomProvider1", params.UserProviderType, true, "https://custom1.example.com"),
testutil.CreateProvider(api.MainnetChainID, "CustomProvider2", params.UserProviderType, false, "https://custom2.example.com"), testutil.CreateProvider(api_common.MainnetChainID, "CustomProvider2", params.UserProviderType, false, "https://custom2.example.com"),
} }
err := s.manager.SetUserRpcProviders(api.MainnetChainID, customProviders) err := s.manager.SetUserRpcProviders(api_common.MainnetChainID, customProviders)
s.Require().NoError(err) s.Require().NoError(err)
// Assert providers // Assert providers
foundNetwork := s.manager.Find(api.MainnetChainID) foundNetwork := s.manager.Find(api_common.MainnetChainID)
s.Require().NotNil(foundNetwork) s.Require().NotNil(foundNetwork)
expectedProviders := append(customProviders, networkhelper.GetEmbeddedProviders(foundNetwork.RpcProviders)...) expectedProviders := append(customProviders, networkhelper.GetEmbeddedProviders(foundNetwork.RpcProviders)...)
testutil.CompareProvidersList(s.T(), expectedProviders, foundNetwork.RpcProviders) testutil.CompareProvidersList(s.T(), expectedProviders, foundNetwork.RpcProviders)
@ -108,23 +107,23 @@ func (s *NetworkManagerTestSuite) TestUserAddsCustomProviders() {
func (s *NetworkManagerTestSuite) TestInitNetworksKeepsUserProviders() { func (s *NetworkManagerTestSuite) TestInitNetworksKeepsUserProviders() {
// Add custom providers // Add custom providers
customProviders := []params.RpcProvider{ customProviders := []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "CustomProvider1", params.UserProviderType, true, "https://custom1.example.com"), testutil.CreateProvider(api_common.MainnetChainID, "CustomProvider1", params.UserProviderType, true, "https://custom1.example.com"),
testutil.CreateProvider(api.MainnetChainID, "CustomProvider2", params.UserProviderType, false, "https://custom2.example.com"), testutil.CreateProvider(api_common.MainnetChainID, "CustomProvider2", params.UserProviderType, false, "https://custom2.example.com"),
} }
err := s.manager.SetUserRpcProviders(api.MainnetChainID, customProviders) err := s.manager.SetUserRpcProviders(api_common.MainnetChainID, customProviders)
s.Require().NoError(err) s.Require().NoError(err)
// Re-initialize networks // Re-initialize networks
initNetworks := []params.Network{ initNetworks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{ *testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"), testutil.CreateProvider(api_common.MainnetChainID, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"),
}), }),
} }
err = s.manager.InitEmbeddedNetworks(initNetworks) err = s.manager.InitEmbeddedNetworks(initNetworks)
s.Require().NoError(err) s.Require().NoError(err)
// Check that custom providers are retained // Check that custom providers are retained
foundNetwork := s.manager.Find(api.MainnetChainID) foundNetwork := s.manager.Find(api_common.MainnetChainID)
s.Require().NotNil(foundNetwork) s.Require().NotNil(foundNetwork)
expectedProviders := append(customProviders, networkhelper.GetEmbeddedProviders(initNetworks[0].RpcProviders)...) expectedProviders := append(customProviders, networkhelper.GetEmbeddedProviders(initNetworks[0].RpcProviders)...)
testutil.CompareProvidersList(s.T(), expectedProviders, foundNetwork.RpcProviders) testutil.CompareProvidersList(s.T(), expectedProviders, foundNetwork.RpcProviders)
@ -136,8 +135,8 @@ func (s *NetworkManagerTestSuite) TestInitNetworksDoesNotSaveEmbeddedProviders()
// Re-initialize networks // Re-initialize networks
initNetworks := []params.Network{ initNetworks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{ *testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"), testutil.CreateProvider(api_common.MainnetChainID, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"),
}), }),
} }
err := s.manager.InitEmbeddedNetworks(initNetworks) err := s.manager.InitEmbeddedNetworks(initNetworks)
@ -153,8 +152,8 @@ func (s *NetworkManagerTestSuite) TestInitNetworksDoesNotSaveEmbeddedProviders()
func (s *NetworkManagerTestSuite) TestInitEmbeddedNetworks() { func (s *NetworkManagerTestSuite) TestInitEmbeddedNetworks() {
// Re-initialize networks // Re-initialize networks
initNetworks := []params.Network{ initNetworks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{ *testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"), testutil.CreateProvider(api_common.MainnetChainID, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"),
}), }),
} }
expectedProviders := networkhelper.GetEmbeddedProviders(initNetworks[0].RpcProviders) expectedProviders := networkhelper.GetEmbeddedProviders(initNetworks[0].RpcProviders)
@ -164,7 +163,7 @@ func (s *NetworkManagerTestSuite) TestInitEmbeddedNetworks() {
// functor tests if embedded providers are present in the networks // functor tests if embedded providers are present in the networks
expectEmbeddedProviders := func(networks []*params.Network) { expectEmbeddedProviders := func(networks []*params.Network) {
for _, network := range networks { for _, network := range networks {
if network.ChainID == api.MainnetChainID { if network.ChainID == api_common.MainnetChainID {
storedEmbeddedProviders := networkhelper.GetEmbeddedProviders(network.RpcProviders) storedEmbeddedProviders := networkhelper.GetEmbeddedProviders(network.RpcProviders)
testutil.CompareProvidersList(s.T(), expectedProviders, storedEmbeddedProviders) testutil.CompareProvidersList(s.T(), expectedProviders, storedEmbeddedProviders)
} }
@ -190,11 +189,11 @@ func (s *NetworkManagerTestSuite) TestInitEmbeddedNetworks() {
combinedNetworks, err := s.manager.GetCombinedNetworks() combinedNetworks, err := s.manager.GetCombinedNetworks()
s.Require().NoError(err) s.Require().NoError(err)
for _, combinedNetwork := range combinedNetworks { for _, combinedNetwork := range combinedNetworks {
if combinedNetwork.Test != nil && combinedNetwork.Test.ChainID == api.MainnetChainID { if combinedNetwork.Test != nil && combinedNetwork.Test.ChainID == api_common.MainnetChainID {
storedEmbeddedProviders := networkhelper.GetEmbeddedProviders(combinedNetwork.Test.RpcProviders) storedEmbeddedProviders := networkhelper.GetEmbeddedProviders(combinedNetwork.Test.RpcProviders)
testutil.CompareProvidersList(s.T(), expectedProviders, storedEmbeddedProviders) testutil.CompareProvidersList(s.T(), expectedProviders, storedEmbeddedProviders)
} }
if combinedNetwork.Prod != nil && combinedNetwork.Prod.ChainID == api.MainnetChainID { if combinedNetwork.Prod != nil && combinedNetwork.Prod.ChainID == api_common.MainnetChainID {
storedEmbeddedProviders := networkhelper.GetEmbeddedProviders(combinedNetwork.Prod.RpcProviders) storedEmbeddedProviders := networkhelper.GetEmbeddedProviders(combinedNetwork.Prod.RpcProviders)
testutil.CompareProvidersList(s.T(), expectedProviders, storedEmbeddedProviders) testutil.CompareProvidersList(s.T(), expectedProviders, storedEmbeddedProviders)
} }
@ -208,14 +207,14 @@ func (s *NetworkManagerTestSuite) TestInitEmbeddedNetworks() {
func (s *NetworkManagerTestSuite) TestLegacyFieldPopulation() { func (s *NetworkManagerTestSuite) TestLegacyFieldPopulation() {
// Create initial test networks with various providers // Create initial test networks with various providers
initNetworks := []params.Network{ initNetworks := []params.Network{
*testutil.CreateNetwork(api.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{ *testutil.CreateNetwork(api_common.MainnetChainID, "Ethereum Mainnet", []params.RpcProvider{
testutil.CreateProvider(api.MainnetChainID, "DirectProvider1", params.EmbeddedDirectProviderType, true, "https://direct1.ethereum.io"), testutil.CreateProvider(api_common.MainnetChainID, "DirectProvider1", params.EmbeddedDirectProviderType, true, "https://direct1.ethereum.io"),
testutil.CreateProvider(api.MainnetChainID, "DirectProvider2", params.EmbeddedDirectProviderType, true, "https://direct2.ethereum.io"), testutil.CreateProvider(api_common.MainnetChainID, "DirectProvider2", params.EmbeddedDirectProviderType, true, "https://direct2.ethereum.io"),
testutil.CreateProvider(api.MainnetChainID, "ProxyProvider1", params.EmbeddedProxyProviderType, true, "https://proxy1.ethereum.io"), testutil.CreateProvider(api_common.MainnetChainID, "ProxyProvider1", params.EmbeddedProxyProviderType, true, "https://proxy1.ethereum.io"),
testutil.CreateProvider(api.MainnetChainID, "ProxyProvider2", params.EmbeddedProxyProviderType, true, "https://proxy2.ethereum.io"), testutil.CreateProvider(api_common.MainnetChainID, "ProxyProvider2", params.EmbeddedProxyProviderType, true, "https://proxy2.ethereum.io"),
testutil.CreateProvider(api.MainnetChainID, "ProxyProvider3", params.EmbeddedProxyProviderType, true, "https://proxy3.ethereum.io"), testutil.CreateProvider(api_common.MainnetChainID, "ProxyProvider3", params.EmbeddedProxyProviderType, true, "https://proxy3.ethereum.io"),
testutil.CreateProvider(api.MainnetChainID, "UserProvider1", params.UserProviderType, true, "https://user1.ethereum.io"), testutil.CreateProvider(api_common.MainnetChainID, "UserProvider1", params.UserProviderType, true, "https://user1.ethereum.io"),
testutil.CreateProvider(api.MainnetChainID, "UserProvider2", params.UserProviderType, true, "https://user2.ethereum.io"), testutil.CreateProvider(api_common.MainnetChainID, "UserProvider2", params.UserProviderType, true, "https://user2.ethereum.io"),
}), }),
} }
@ -244,10 +243,10 @@ func (s *NetworkManagerTestSuite) TestLegacyFieldPopulation() {
func (s *NetworkManagerTestSuite) TestLegacyFieldPopulationWithoutUserProviders() { func (s *NetworkManagerTestSuite) TestLegacyFieldPopulationWithoutUserProviders() {
// Create a test network with only EmbeddedDirect and EmbeddedProxy providers // Create a test network with only EmbeddedDirect and EmbeddedProxy providers
initNetworks := []params.Network{ initNetworks := []params.Network{
*testutil.CreateNetwork(api.SepoliaChainID, "Sepolia Testnet", []params.RpcProvider{ *testutil.CreateNetwork(api_common.SepoliaChainID, "Sepolia Testnet", []params.RpcProvider{
testutil.CreateProvider(api.SepoliaChainID, "DirectProvider1", params.EmbeddedDirectProviderType, true, "https://direct1.sepolia.io"), testutil.CreateProvider(api_common.SepoliaChainID, "DirectProvider1", params.EmbeddedDirectProviderType, true, "https://direct1.sepolia.io"),
testutil.CreateProvider(api.SepoliaChainID, "ProxyProvider1", params.EmbeddedProxyProviderType, true, "https://proxy1.sepolia.io"), testutil.CreateProvider(api_common.SepoliaChainID, "ProxyProvider1", params.EmbeddedProxyProviderType, true, "https://proxy1.sepolia.io"),
testutil.CreateProvider(api.SepoliaChainID, "ProxyProvider2", params.EmbeddedProxyProviderType, true, "https://proxy2.sepolia.io"), testutil.CreateProvider(api_common.SepoliaChainID, "ProxyProvider2", params.EmbeddedProxyProviderType, true, "https://proxy2.sepolia.io"),
}), }),
} }
@ -303,25 +302,25 @@ func (s *NetworkManagerTestSuite) TestSetActive() {
var n *params.Network var n *params.Network
// Check that the "Base" network is active by default // Check that the "Base" network is active by default
n = s.manager.Find(api.BaseChainID) n = s.manager.Find(api_common.BaseChainID)
s.Require().NotNil(n) s.Require().NotNil(n)
s.True(n.IsActive) s.True(n.IsActive)
// Set the "Base" network to inactive // Set the "Base" network to inactive
err = s.manager.SetActive(api.BaseChainID, false) err = s.manager.SetActive(api_common.BaseChainID, false)
s.Require().NoError(err) s.Require().NoError(err)
// Verify the network was set to inactive // Verify the network was set to inactive
n = s.manager.Find(api.BaseChainID) n = s.manager.Find(api_common.BaseChainID)
s.Require().NotNil(n) s.Require().NotNil(n)
s.False(n.IsActive) s.False(n.IsActive)
// Set the "Base" network to active // Set the "Base" network to active
err = s.manager.SetActive(api.BaseChainID, true) err = s.manager.SetActive(api_common.BaseChainID, true)
s.Require().NoError(err) s.Require().NoError(err)
// Verify the network was set to active // Verify the network was set to active
n = s.manager.Find(api.BaseChainID) n = s.manager.Find(api_common.BaseChainID)
s.Require().NotNil(n) s.Require().NotNil(n)
s.True(n.IsActive) s.True(n.IsActive)
} }
@ -331,11 +330,11 @@ func (s *NetworkManagerTestSuite) TestSetActiveNotDeactivatable() {
var n *params.Network var n *params.Network
// Try to set Ethereum Mainnet to inactive (should fail) // Try to set Ethereum Mainnet to inactive (should fail)
err = s.manager.SetActive(api.MainnetChainID, false) err = s.manager.SetActive(api_common.MainnetChainID, false)
s.Require().Error(err) s.Require().Error(err)
// Verify the network was not set to inactive // Verify the network was not set to inactive
n = s.manager.Find(api.MainnetChainID) n = s.manager.Find(api_common.MainnetChainID)
s.Require().NotNil(n) s.Require().NotNil(n)
s.True(n.IsActive) s.True(n.IsActive)
} }
@ -350,16 +349,16 @@ func (s *NetworkManagerTestSuite) TestSetActiveMaxNumberOfActiveNetworks() {
s.Require().Len(activeNetworks, network.MaxActiveNetworks) s.Require().Len(activeNetworks, network.MaxActiveNetworks)
// Check that the "Optimistic Ethereum" network is inactive by default // Check that the "Optimistic Ethereum" network is inactive by default
n = s.manager.Find(api.OptimismChainID) n = s.manager.Find(api_common.OptimismChainID)
s.Require().NotNil(n) s.Require().NotNil(n)
s.False(n.IsActive) s.False(n.IsActive)
// Try to set the "Optimistic Ethereum" network to active (should fail due to number networks active) // Try to set the "Optimistic Ethereum" network to active (should fail due to number networks active)
err = s.manager.SetActive(api.OptimismChainID, true) err = s.manager.SetActive(api_common.OptimismChainID, true)
s.Require().Error(err) s.Require().Error(err)
// Verify the network was not set to active // Verify the network was not set to active
n = s.manager.Find(api.OptimismChainID) n = s.manager.Find(api_common.OptimismChainID)
s.Require().NotNil(n) s.Require().NotNil(n)
s.False(n.IsActive) s.False(n.IsActive)
} }

4
rpc/network/testutil/testutil.go
View File

@ -3,7 +3,7 @@ package testutil
import ( import (
"github.com/stretchr/testify/require" "github.com/stretchr/testify/require"
"github.com/status-im/status-go/api" api_common "github.com/status-im/status-go/api/common"
"github.com/status-im/status-go/params" "github.com/status-im/status-go/params"
) )
@ -38,7 +38,7 @@ func CreateNetwork(chainID uint64, chainName string, providers []params.RpcProvi
Enabled: true, Enabled: true,
ChainColor: "#E90101", ChainColor: "#E90101",
ShortName: "eth", ShortName: "eth",
RelatedChainID: api.OptimismSepoliaChainID, RelatedChainID: api_common.OptimismSepoliaChainID,
RpcProviders: providers, RpcProviders: providers,
IsActive: true, IsActive: true,
IsDeactivatable: true, IsDeactivatable: true,

22
services/connector/commands/test_helpers.go
View File

@ -14,6 +14,7 @@ import (
"github.com/status-im/status-go/params" "github.com/status-im/status-go/params"
mock_rpcclient "github.com/status-im/status-go/rpc/mock/client" mock_rpcclient "github.com/status-im/status-go/rpc/mock/client"
"github.com/status-im/status-go/rpc/network" "github.com/status-im/status-go/rpc/network"
network_testutil "github.com/status-im/status-go/rpc/network/testutil"
persistence "github.com/status-im/status-go/services/connector/database" persistence "github.com/status-im/status-go/services/connector/database"
walletCommon "github.com/status-im/status-go/services/wallet/common" walletCommon "github.com/status-im/status-go/services/wallet/common"
"github.com/status-im/status-go/signal" "github.com/status-im/status-go/signal"
@ -69,18 +70,15 @@ func setupCommand(t *testing.T, method string) (state testState, close func()) {
networkManager := network.NewManager(state.db, nil, nil, nil) networkManager := network.NewManager(state.db, nil, nil, nil)
require.NotNil(t, networkManager) require.NotNil(t, networkManager)
err := networkManager.InitEmbeddedNetworks([]params.Network{ initNetworks := []params.Network{
{ *network_testutil.CreateNetwork(walletCommon.EthereumMainnet, "Ethereum Mainnet", []params.RpcProvider{
ChainID: walletCommon.EthereumMainnet, network_testutil.CreateProvider(walletCommon.EthereumMainnet, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"),
ChainName: "Ethereum Mainnet", }),
Layer: 1, *network_testutil.CreateNetwork(walletCommon.OptimismMainnet, "Optimism Mainnet", []params.RpcProvider{
}, network_testutil.CreateProvider(walletCommon.OptimismMainnet, "Optimism Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.optimism.io"),
{ }),
ChainID: walletCommon.OptimismMainnet, }
ChainName: "Optimism Mainnet", err := networkManager.InitEmbeddedNetworks(initNetworks)
Layer: 1,
},
})
require.NoError(t, err) require.NoError(t, err)
state.handler = NewClientSideHandler(state.db) state.handler = NewClientSideHandler(state.db)

22
services/connector/test_helpers.go
View File

@ -14,6 +14,7 @@ import (
"github.com/status-im/status-go/params" "github.com/status-im/status-go/params"
mock_rpcclient "github.com/status-im/status-go/rpc/mock/client" mock_rpcclient "github.com/status-im/status-go/rpc/mock/client"
"github.com/status-im/status-go/rpc/network" "github.com/status-im/status-go/rpc/network"
network_testutil "github.com/status-im/status-go/rpc/network/testutil"
walletCommon "github.com/status-im/status-go/services/wallet/common" walletCommon "github.com/status-im/status-go/services/wallet/common"
"github.com/status-im/status-go/t/helpers" "github.com/status-im/status-go/t/helpers"
"github.com/status-im/status-go/walletdatabase" "github.com/status-im/status-go/walletdatabase"
@ -73,18 +74,15 @@ func setupTests(t *testing.T) (state testState, close func()) {
networkManager := network.NewManager(state.db, nil, nil, nil) networkManager := network.NewManager(state.db, nil, nil, nil)
require.NotNil(t, networkManager) require.NotNil(t, networkManager)
err = networkManager.InitEmbeddedNetworks([]params.Network{ initNetworks := []params.Network{
{ *network_testutil.CreateNetwork(walletCommon.EthereumMainnet, "Ethereum Mainnet", []params.RpcProvider{
ChainID: walletCommon.EthereumMainnet, network_testutil.CreateProvider(walletCommon.EthereumMainnet, "Infura Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.infura.io"),
ChainName: "Ethereum Mainnet", }),
Layer: 1, *network_testutil.CreateNetwork(walletCommon.OptimismMainnet, "Optimism Mainnet", []params.RpcProvider{
}, network_testutil.CreateProvider(walletCommon.OptimismMainnet, "Optimism Mainnet", params.EmbeddedProxyProviderType, true, "https://mainnet.optimism.io"),
{ }),
ChainID: walletCommon.OptimismMainnet, }
ChainName: "Optimism Mainnet", err = networkManager.InitEmbeddedNetworks(initNetworks)
Layer: 1,
},
})
require.NoError(t, err) require.NoError(t, err)
state.rpcClient.EXPECT().GetNetworkManager().AnyTimes().Return(networkManager) state.rpcClient.EXPECT().GetNetworkManager().AnyTimes().Return(networkManager)

17
services/wallet/api_test.go
View File

@ -10,6 +10,7 @@ import (
"time" "time"
"github.com/status-im/status-go/params/networkhelper" "github.com/status-im/status-go/params/networkhelper"
"github.com/status-im/status-go/rpc/network/testutil"
"github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/event"
@ -136,20 +137,10 @@ func TestAPI_GetAddressDetails(t *testing.T) {
defer serverWith1SecDelay.Close() defer serverWith1SecDelay.Close()
networks := []params.Network{ networks := []params.Network{
{ *testutil.CreateNetwork(chainID, "Ethereum Mainnet", []params.RpcProvider{
ChainID: chainID, *params.NewProxyProvider(chainID, "Test Provider", serverWith1SecDelay.URL+"/nodefleet/", false),
ChainName: "Ethereum Mainnet",
RpcProviders: []params.RpcProvider{
{
ChainID: chainID,
Name: "Test Provider",
URL: serverWith1SecDelay.URL + "/nodefleet/",
Type: params.EmbeddedProxyProviderType,
Enabled: true,
AuthType: params.NoAuth,
},
},
}, },
),
} }
networks = networkhelper.OverrideBasicAuth(networks, params.EmbeddedProxyProviderType, true, gofakeit.Username(), gofakeit.LetterN(5)) networks = networkhelper.OverrideBasicAuth(networks, params.EmbeddedProxyProviderType, true, gofakeit.Username(), gofakeit.LetterN(5))