status-im
/
status-go
mirror of https://github.com/status-im/status-go.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

chore_: completely remove goerli from the code

This commit is contained in:
Sale Djenic 2024-10-15 09:29:21 +02:00
parent 93e88d9774
commit 0c7a580110
44 changed files with 98 additions and 311 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
api/backend_test.go
View File

@ -1806,13 +1806,10 @@ func TestRestoreKeycardAccountAndLogin(t *testing.T) {
"raribleMainnetApiKey": "",
"raribleTestnetApiKey": "",
"alchemyEthereumMainnetToken": "",
"alchemyEthereumGoerliToken": "",
"alchemyEthereumSepoliaToken": "",
"alchemyArbitrumMainnetToken": "",
"alchemyArbitrumGoerliToken": "",
"alchemyArbitrumSepoliaToken": "",
"alchemyOptimismMainnetToken": "",
"alchemyOptimismGoerliToken": "",
"alchemyOptimismSepoliaToken": "",
},
"torrentConfigEnabled": false,

86
api/default_networks.go
View File

@ -11,13 +11,10 @@ import (
const (
mainnetChainID uint64 = 1
goerliChainID uint64 = 5
sepoliaChainID uint64 = 11155111
optimismChainID uint64 = 10
optimismGoerliChainID uint64 = 420
optimismSepoliaChainID uint64 = 11155420
arbitrumChainID uint64 = 42161
arbitrumGoerliChainID uint64 = 421613
arbitrumSepoliaChainID uint64 = 421614
sntSymbol = "SNT"
sttSymbol = "STT"
@ -44,30 +41,10 @@ func mainnet(stageName string) params.Network {
IsTest: false,
Layer: 1,
Enabled: true,
RelatedChainID: goerliChainID,
RelatedChainID: sepoliaChainID,
}
}
func goerli(stageName string) params.Network {
return params.Network{
ChainID: goerliChainID,
ChainName: "Mainnet",
RPCURL: "https://goerli.infura.io/v3/",
FallbackURL: "",
BlockExplorerURL: "https://goerli.etherscan.io/",
IconURL: "network/Network=Ethereum",
ChainColor: "#627EEA",
ShortName: "goEth",
NativeCurrencyName: "Ether",
NativeCurrencySymbol: "ETH",
NativeCurrencyDecimals: 18,
IsTest: true,
Layer: 1,
Enabled: true,
RelatedChainID: mainnetChainID,
}
}
func sepolia(stageName string) params.Network {
return params.Network{
ChainID: sepoliaChainID,
@ -110,27 +87,7 @@ func optimism(stageName string) params.Network {
IsTest: false,
Layer: 2,
Enabled: true,
RelatedChainID: optimismGoerliChainID,
}
}
func optimismGoerli(stageName string) params.Network {
return params.Network{
ChainID: optimismGoerliChainID,
ChainName: "Optimism",
RPCURL: "https://optimism-goerli.infura.io/v3/",
FallbackURL: "",
BlockExplorerURL: "https://goerli-optimism.etherscan.io/",
IconURL: "network/Network=Optimism",
ChainColor: "#E90101",
ShortName: "goOpt",
NativeCurrencyName: "Ether",
NativeCurrencySymbol: "ETH",
NativeCurrencyDecimals: 18,
IsTest: true,
Layer: 2,
Enabled: false,
RelatedChainID: optimismChainID,
RelatedChainID: optimismSepoliaChainID,
}
}
@ -176,27 +133,7 @@ func arbitrum(stageName string) params.Network {
IsTest: false,
Layer: 2,
Enabled: true,
RelatedChainID: arbitrumGoerliChainID,
}
}
func arbitrumGoerli(stageName string) params.Network {
return params.Network{
ChainID: arbitrumGoerliChainID,
ChainName: "Arbitrum",
RPCURL: "https://arbitrum-goerli.infura.io/v3/",
FallbackURL: "",
BlockExplorerURL: "https://goerli.arbiscan.io/",
IconURL: "network/Network=Arbitrum",
ChainColor: "#51D0F0",
ShortName: "goArb",
NativeCurrencyName: "Ether",
NativeCurrencySymbol: "ETH",
NativeCurrencyDecimals: 18,
IsTest: true,
Layer: 2,
Enabled: false,
RelatedChainID: arbitrumChainID,
RelatedChainID: arbitrumSepoliaChainID,
}
}
@ -226,13 +163,10 @@ func arbitrumSepolia(stageName string) params.Network {
func defaultNetworks(stageName string) []params.Network {
return []params.Network{
mainnet(stageName),
goerli(stageName),
sepolia(stageName),
optimism(stageName),
optimismGoerli(stageName),
optimismSepolia(stageName),
arbitrum(stageName),
arbitrumGoerli(stageName),
arbitrumSepolia(stageName),
}
}
@ -242,11 +176,6 @@ var mainnetGanacheTokenOverrides = params.TokenOverride{
Address: ganacheTokenAddress,
}
var goerliGanacheTokenOverrides = params.TokenOverride{
Symbol: sttSymbol,
Address: ganacheTokenAddress,
}
func setRPCs(networks []params.Network, request *requests.WalletSecretsConfig) []params.Network {
var networksWithRPC []params.Network
@ -275,11 +204,10 @@ func setRPCs(networks []params.Network, request *requests.WalletSecretsConfig) [
if request.GanacheURL != "" {
n.RPCURL = request.GanacheURL
n.FallbackURL = request.GanacheURL
switch n.ChainID {
case mainnetChainID:
n.TokenOverrides = []params.TokenOverride{mainnetGanacheTokenOverrides}
case goerliChainID:
n.TokenOverrides = []params.TokenOverride{goerliGanacheTokenOverrides}
if n.ChainID == mainnetChainID {
n.TokenOverrides = []params.TokenOverride{
mainnetGanacheTokenOverrides,
}
}
}

33
api/default_networks_test.go
View File

@ -23,24 +23,16 @@ func TestBuildDefaultNetworks(t *testing.T) {
actualNetworks := BuildDefaultNetworks(&request.WalletSecretsConfig)
require.Len(t, actualNetworks, 9)
ignoreDefaultRPCURLCheck := false // TODO: used just because of Goerli, remove once we remove Goerli from the default networks
require.Len(t, actualNetworks, 6)
for _, n := range actualNetworks {
var err error
switch n.ChainID {
case mainnetChainID:
case goerliChainID:
ignoreDefaultRPCURLCheck = true
case sepoliaChainID:
case optimismChainID:
case optimismGoerliChainID:
ignoreDefaultRPCURLCheck = true
case optimismSepoliaChainID:
case arbitrumChainID:
case arbitrumGoerliChainID:
ignoreDefaultRPCURLCheck = true
case arbitrumSepoliaChainID:
default:
err = errors.Errorf("unexpected chain id: %d", n.ChainID)
@ -48,13 +40,11 @@ func TestBuildDefaultNetworks(t *testing.T) {
require.NoError(t, err)
// check default chains
if !ignoreDefaultRPCURLCheck {
// DefaultRPCURL and DefaultFallbackURL are mandatory
require.True(t, strings.Contains(n.DefaultRPCURL, stageName))
require.True(t, strings.Contains(n.DefaultFallbackURL, stageName))
if n.DefaultFallbackURL2 != "" {
require.True(t, strings.Contains(actualNetworks[0].DefaultFallbackURL2, stageName))
}
// DefaultRPCURL and DefaultFallbackURL are mandatory
require.True(t, strings.Contains(n.DefaultRPCURL, stageName))
require.True(t, strings.Contains(n.DefaultFallbackURL, stageName))
if n.DefaultFallbackURL2 != "" {
require.True(t, strings.Contains(actualNetworks[0].DefaultFallbackURL2, stageName))
}
// check fallback options
@ -73,12 +63,11 @@ func TestBuildDefaultNetworksGanache(t *testing.T) {
actualNetworks := BuildDefaultNetworks(&request.WalletSecretsConfig)
require.Len(t, actualNetworks, 9)
require.Len(t, actualNetworks, 6)
for _, n := range actualNetworks {
require.True(t, strings.Contains(n.RPCURL, ganacheURL))
require.True(t, strings.Contains(n.FallbackURL, ganacheURL))
}
require.Equal(t, mainnetChainID, actualNetworks[0].ChainID)
@ -87,12 +76,4 @@ func TestBuildDefaultNetworksGanache(t *testing.T) {
require.Len(t, actualNetworks[0].TokenOverrides, 1)
require.Equal(t, sntSymbol, actualNetworks[0].TokenOverrides[0].Symbol)
require.Equal(t, ganacheTokenAddress, actualNetworks[0].TokenOverrides[0].Address)
require.Equal(t, goerliChainID, actualNetworks[1].ChainID)
require.NotNil(t, actualNetworks[1].TokenOverrides)
require.Len(t, actualNetworks[1].TokenOverrides, 1)
require.Equal(t, sttSymbol, actualNetworks[1].TokenOverrides[0].Symbol)
require.Equal(t, ganacheTokenAddress, actualNetworks[1].TokenOverrides[0].Address)
}

9
api/defaults.go
View File

@ -198,27 +198,18 @@ func buildWalletConfig(request *requests.WalletSecretsConfig, statusProxyEnabled
if request.AlchemyEthereumMainnetToken != "" {
walletConfig.AlchemyAPIKeys[mainnetChainID] = request.AlchemyEthereumMainnetToken
}
if request.AlchemyEthereumGoerliToken != "" {
walletConfig.AlchemyAPIKeys[goerliChainID] = request.AlchemyEthereumGoerliToken
}
if request.AlchemyEthereumSepoliaToken != "" {
walletConfig.AlchemyAPIKeys[sepoliaChainID] = request.AlchemyEthereumSepoliaToken
}
if request.AlchemyArbitrumMainnetToken != "" {
walletConfig.AlchemyAPIKeys[arbitrumChainID] = request.AlchemyArbitrumMainnetToken
}
if request.AlchemyArbitrumGoerliToken != "" {
walletConfig.AlchemyAPIKeys[arbitrumGoerliChainID] = request.AlchemyArbitrumGoerliToken
}
if request.AlchemyArbitrumSepoliaToken != "" {
walletConfig.AlchemyAPIKeys[arbitrumSepoliaChainID] = request.AlchemyArbitrumSepoliaToken
}
if request.AlchemyOptimismMainnetToken != "" {
walletConfig.AlchemyAPIKeys[optimismChainID] = request.AlchemyOptimismMainnetToken
}
if request.AlchemyOptimismGoerliToken != "" {
walletConfig.AlchemyAPIKeys[optimismGoerliChainID] = request.AlchemyOptimismGoerliToken
}
if request.AlchemyOptimismSepoliaToken != "" {
walletConfig.AlchemyAPIKeys[optimismSepoliaChainID] = request.AlchemyOptimismSepoliaToken
}

6
appdatabase/database_test.go
View File

@ -49,10 +49,10 @@ func Test_GetDBFilename(t *testing.T) {
}
const (
erc20ReceiptTestDataTemplate = `{"type":"0x2","root":"0x","status":"0x%d","cumulativeGasUsed":"0x10f8d2c","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000001008000000000000000000000000000000000000002000000000020000000000000000000800000000000000000000000010000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000800000000000000000000","logs":[{"address":"0x98339d8c260052b7ad81c28c16c0b98420f2b46a","topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x0000000000000000000000000000000000000000000000000000000000000000","0x000000000000000000000000e2d622c817878da5143bbe06866ca8e35273ba8a"],"data":"0x0000000000000000000000000000000000000000000000000000000000989680","blockNumber":"0x825527","transactionHash":"0xdcaa0fc7fe2e0d1f1343d1f36807344bb4fd26cda62ad8f9d8700e2c458cc79a","transactionIndex":"0x6c","blockHash":"0x69e0f829a557052c134cd7e21c220507d91bc35c316d3c47217e9bd362270274","logIndex":"0xcd","removed":false}],"transactionHash":"0xdcaa0fc7fe2e0d1f1343d1f36807344bb4fd26cda62ad8f9d8700e2c458cc79a","contractAddress":"0x0000000000000000000000000000000000000000","gasUsed":"0x8623","blockHash":"0x69e0f829a557052c134cd7e21c220507d91bc35c316d3c47217e9bd362270274","blockNumber":"0x825527","transactionIndex":"0x6c"}`
erc20TxTestData = `{"type":"0x2","nonce":"0x3d","gasPrice":"0x0","maxPriorityFeePerGas":"0x8c347c90","maxFeePerGas":"0x45964d43a4","gas":"0x8623","value":"0x0","input":"0x40c10f19000000000000000000000000e2d622c817878da5143bbe06866ca8e35273ba8a0000000000000000000000000000000000000000000000000000000000989680","v":"0x0","r":"0xbcac4bb290d48b467bb18ac67e98050b5f316d2c66b2f75dcc1d63a45c905d21","s":"0x10c15517ea9cabd7fe134b270daabf5d2e8335e935d3e021f54a4efaffb37cd2","to":"0x98339d8c260052b7ad81c28c16c0b98420f2b46a","chainId":"0x5","accessList":[],"hash":"0xdcaa0fc7fe2e0d1f1343d1f36807344bb4fd26cda62ad8f9d8700e2c458cc79a"}`
erc20ReceiptTestDataTemplate = `{"type":"0x2","root":"0x","status":"0x%d","cumulativeGasUsed":"0x10f8d2c","logsBloom":"0x00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004000001008000000000000000000000000000000000000002000000000020000000000000000000800000000000000000000000010000000080000000000000000000000000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000800000000000000000000","logs":[{"address":"0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238","topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x0000000000000000000000000000000000000000000000000000000000000000","0x000000000000000000000000e2d622c817878da5143bbe06866ca8e35273ba8a"],"data":"0x0000000000000000000000000000000000000000000000000000000000989680","blockNumber":"0x825527","transactionHash":"0xdcaa0fc7fe2e0d1f1343d1f36807344bb4fd26cda62ad8f9d8700e2c458cc79a","transactionIndex":"0x6c","blockHash":"0x69e0f829a557052c134cd7e21c220507d91bc35c316d3c47217e9bd362270274","logIndex":"0xcd","removed":false}],"transactionHash":"0xdcaa0fc7fe2e0d1f1343d1f36807344bb4fd26cda62ad8f9d8700e2c458cc79a","contractAddress":"0x0000000000000000000000000000000000000000","gasUsed":"0x8623","blockHash":"0x69e0f829a557052c134cd7e21c220507d91bc35c316d3c47217e9bd362270274","blockNumber":"0x825527","transactionIndex":"0x6c"}`
erc20TxTestData = `{"type":"0x2","nonce":"0x3d","gasPrice":"0x0","maxPriorityFeePerGas":"0x8c347c90","maxFeePerGas":"0x45964d43a4","gas":"0x8623","value":"0x0","input":"0x40c10f19000000000000000000000000e2d622c817878da5143bbe06866ca8e35273ba8a0000000000000000000000000000000000000000000000000000000000989680","v":"0x0","r":"0xbcac4bb290d48b467bb18ac67e98050b5f316d2c66b2f75dcc1d63a45c905d21","s":"0x10c15517ea9cabd7fe134b270daabf5d2e8335e935d3e021f54a4efaffb37cd2","to":"0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238","chainId":"0x5","accessList":[],"hash":"0xdcaa0fc7fe2e0d1f1343d1f36807344bb4fd26cda62ad8f9d8700e2c458cc79a"}`
erc20LogTestData = `{"address":"0x98339d8c260052b7ad81c28c16c0b98420f2b46a","topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x0000000000000000000000000000000000000000000000000000000000000000","0x000000000000000000000000e2d622c817878da5143bbe06866ca8e35273ba8a"],"data":"0x0000000000000000000000000000000000000000000000000000000000989680","blockNumber":"0x825527","transactionHash":"0xdcaa0fc7fe2e0d1f1343d1f36807344bb4fd26cda62ad8f9d8700e2c458cc79a","transactionIndex":"0x6c","blockHash":"0x69e0f829a557052c134cd7e21c220507d91bc35c316d3c47217e9bd362270274","logIndex":"0xcd","removed":false}`
erc20LogTestData = `{"address":"0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238","topics":["0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef","0x0000000000000000000000000000000000000000000000000000000000000000","0x000000000000000000000000e2d622c817878da5143bbe06866ca8e35273ba8a"],"data":"0x0000000000000000000000000000000000000000000000000000000000989680","blockNumber":"0x825527","transactionHash":"0xdcaa0fc7fe2e0d1f1343d1f36807344bb4fd26cda62ad8f9d8700e2c458cc79a","transactionIndex":"0x6c","blockHash":"0x69e0f829a557052c134cd7e21c220507d91bc35c316d3c47217e9bd362270274","logIndex":"0xcd","removed":false}`
ethReceiptTestData = `{
"type": "0x2",
"root": "0x",

1
appdatabase/migrations/sql/1728977282_remove_goerli_from_settings_table.up.sql Normal file
View File

@ -0,0 +1 @@
ALTER TABLE settings DROP COLUMN is_goerli_enabled;

2
cmd/node-canary/main.go
View File

@ -113,7 +113,7 @@ func makeNodeConfig() (*params.NodeConfig, error) {
return nil, err
}
nodeConfig, err := params.NewNodeConfigWithDefaults(path.Join(workDir, ".ethereum"), uint64(params.GoerliNetworkID))
nodeConfig, err := params.NewNodeConfigWithDefaults(path.Join(workDir, ".ethereum"), uint64(params.SepoliaNetworkID))
if err != nil {
return nil, err
}

6
cmd/ping-community/main.go
View File

@ -55,10 +55,10 @@ var (
dataDir = flag.String("dir", getDefaultDataDir(), "Directory used by node to store data")
networkID = flag.Int(
"network-id",
params.GoerliNetworkID,
params.SepoliaNetworkID,
fmt.Sprintf(
"A network ID: %d (Mainnet), %d (Goerli)",
params.MainNetworkID, params.GoerliNetworkID,
"A network ID: %d (Mainnet), %d (Sepolia)",
params.MainNetworkID, params.SepoliaNetworkID,
),
)
listenAddr = flag.String("addr", "", "address to bind listener to")

6
cmd/populate-db/main.go
View File

@ -64,10 +64,10 @@ var (
dataDir = flag.String("dir", getDefaultDataDir(), "Directory used by node to store data")
networkID = flag.Int(
"network-id",
params.GoerliNetworkID,
params.SepoliaNetworkID,
fmt.Sprintf(
"A network ID: %d (Mainnet), %d (Goerli)",
params.MainNetworkID, params.GoerliNetworkID,
"A network ID: %d (Mainnet), %d (Sepolia)",
params.MainNetworkID, params.SepoliaNetworkID,
),
)
listenAddr = flag.String("addr", "", "address to bind listener to")

6
cmd/spiff-workflow/main.go
View File

@ -56,10 +56,10 @@ var (
dataDir = flag.String("dir", getDefaultDataDir(), "Directory used by node to store data")
networkID = flag.Int(
"network-id",
params.GoerliNetworkID,
params.SepoliaNetworkID,
fmt.Sprintf(
"A network ID: %d (Mainnet), %d (Goerli)",
params.MainNetworkID, params.GoerliNetworkID,
"A network ID: %d (Mainnet), %d (Sepolia)",
params.MainNetworkID, params.SepoliaNetworkID,
),
)
listenAddr = flag.String("addr", "", "address to bind listener to")

6
cmd/statusd/main.go
View File

@ -60,10 +60,10 @@ var (
mailserver = flag.Bool("mailserver", false, "Enable Mail Server with default configuration")
networkID = flag.Int(
"network-id",
params.GoerliNetworkID,
params.SepoliaNetworkID,
fmt.Sprintf(
"A network ID: %d (Mainnet), %d (Goerli)",
params.MainNetworkID, params.GoerliNetworkID,
"A network ID: %d (Mainnet), %d (Sepolia)",
params.MainNetworkID, params.SepoliaNetworkID,
),
)
fleet = flag.String(

3
contracts/balancechecker/address.go
View File

@ -12,9 +12,6 @@ var contractDataByChainID = map[uint64]common.Address{
1: common.HexToAddress("0x040EA8bFE441597849A9456182fa46D38B75BC05"), // mainnet
10: common.HexToAddress("0x55bD303eA3D50FC982A8a5b43972d7f38D129bbF"), // optimism
42161: common.HexToAddress("0x54764eF12d29b249fDC7FC3caDc039955A396A8e"), // arbitrum
5: common.HexToAddress("0xA5522A3194B78Dd231b64d0ccd6deA6156DCa7C8"), // goerli
421613: common.HexToAddress("0x54764eF12d29b249fDC7FC3caDc039955A396A8e"), // goerli arbitrum
420: common.HexToAddress("0x55bD303eA3D50FC982A8a5b43972d7f38D129bbF"), // goerli optimism
11155111: common.HexToAddress("0x55bD303eA3D50FC982A8a5b43972d7f38D129bbF"), // sepolia
421614: common.HexToAddress("0x54764eF12d29b249fDC7FC3caDc039955A396A8e"), // sepolia arbitrum
11155420: common.HexToAddress("0x55bD303eA3D50FC982A8a5b43972d7f38D129bbF"), // sepolia optimism

3
contracts/community-tokens/deployer/address.go
View File

@ -11,11 +11,8 @@ var errorNotAvailableOnChainID = errors.New("deployer contract not available for
// addresses can be found on https://github.com/status-im/communities-contracts#deployments
var contractAddressByChainID = map[uint64]common.Address{
1: common.HexToAddress("0xB3Ef5B0825D5f665bE14394eea41E684CE96A4c5"), // Mainnet
5: common.HexToAddress("0x81f4951ff8859d305F47A4574B206cF64C0d2645"), // Goerli
10: common.HexToAddress("0x31463D22750324C8721FF7751584EF62F2ff93b3"), // Optimism
420: common.HexToAddress("0xfFa8A255D905c909379859eA45B959D090DDC2d4"), // Optimism Goerli
42161: common.HexToAddress("0x744Fd6e98dad09Fb8CCF530B5aBd32B56D64943b"), // Arbitrum
421613: common.HexToAddress("0x7Ff554af5b6624db2135E4364F416d1D397f43e6"), // Arbitrum Goerli
11155111: common.HexToAddress("0xCDE984e57cdb88c70b53437cc694345B646371f9"), // Sepolia
421614: common.HexToAddress("0x7Ff554af5b6624db2135E4364F416d1D397f43e6"), // Arbitrum Sepolia
11155420: common.HexToAddress("0xcE2A896eEA2F585BC0C3753DC8116BbE2AbaE541"), // Optimism Sepolia

3
contracts/directory/address.go
View File

@ -9,8 +9,7 @@ import (
var errorNotAvailableOnChainID = errors.New("not available for chainID")
var contractAddressByChainID = map[uint64]common.Address{
10: common.HexToAddress("0xA8d270048a086F5807A8dc0a9ae0e96280C41e3A"), // optimism mainnet
420: common.HexToAddress("0xB3Ef5B0825D5f665bE14394eea41E684CE96A4c5"), // optimism goerli testnet
10: common.HexToAddress("0xA8d270048a086F5807A8dc0a9ae0e96280C41e3A"), // optimism mainnet
}
func ContractAddress(chainID uint64) (common.Address, error) {

3
contracts/ethscan/address.go
View File

@ -15,11 +15,8 @@ type ContractData struct {
var contractDataByChainID = map[uint64]ContractData{
1: {common.HexToAddress("0x08A8fDBddc160A7d5b957256b903dCAb1aE512C5"), 12_194_222}, // mainnet
5: {common.HexToAddress("0x08A8fDBddc160A7d5b957256b903dCAb1aE512C5"), 4_578_854}, // goerli
10: {common.HexToAddress("0x9e5076df494fc949abc4461f4e57592b81517d81"), 34_421_097}, // optimism
420: {common.HexToAddress("0xf532c75239fa61b66d31e73f44300c46da41aadd"), 2_236_534}, // goerli optimism
42161: {common.HexToAddress("0xbb85398092b83a016935a17fc857507b7851a071"), 70_031_945}, // arbitrum
421613: {common.HexToAddress("0xec21ebe1918e8975fc0cd0c7747d318c00c0acd5"), 818_155}, // goerli arbitrum
777333: {common.HexToAddress("0x0000000000000000000000000000000000777333"), 50}, // unit tests
11155111: {common.HexToAddress("0xec21ebe1918e8975fc0cd0c7747d318c00c0acd5"), 4_366_506}, // sepolia
421614: {common.HexToAddress("0xec21Ebe1918E8975FC0CD0c7747D318C00C0aCd5"), 553_947}, // sepolia arbitrum

1
contracts/resolver/address.go
View File

@ -10,7 +10,6 @@ var errorNotAvailableOnChainID = errors.New("not available for chainID")
var contractAddressByChainID = map[uint64]common.Address{
1: common.HexToAddress("0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"), // mainnet
5: common.HexToAddress("0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"), // goerli
11155111: common.HexToAddress("0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e"), // sepolia testnet
}

1
contracts/snt/address.go
View File

@ -10,7 +10,6 @@ var errorNotAvailableOnChainID = errors.New("not available for chainID")
var contractAddressByChainID = map[uint64]common.Address{
1: common.HexToAddress("0x744d70fdbe2ba4cf95131626614a1763df805b9e"), // mainnet
5: common.HexToAddress("0x3d6afaa395c31fcd391fe3d562e75fe9e8ec7e6a"), // goerli
11155111: common.HexToAddress("0xE452027cdEF746c7Cd3DB31CB700428b16cD8E51"), // sepolia
}

3
contracts/stickers/address.go
View File

@ -10,19 +10,16 @@ var errorNotAvailableOnChainID = errors.New("not available for chainID")
var stickerTypeByChainID = map[uint64]common.Address{
1: common.HexToAddress("0x0577215622f43a39f4bc9640806dfea9b10d2a36"), // mainnet
5: common.HexToAddress("0x07f7CB0C0a4ab3e0999AfE8b3997Da34880f05d0"), // goerli testnet
11155111: common.HexToAddress("0x5acbae26c23427aeee0a7f26949f093577a61aab"), // sepolia testnet
}
var stickerMarketByChainID = map[uint64]common.Address{
1: common.HexToAddress("0x12824271339304d3a9f7e096e62a2a7e73b4a7e7"), // mainnet
5: common.HexToAddress("0xf1E149A7DF70D5Ff1E265daAa738d785D3274717"), // goerli testnet
11155111: common.HexToAddress("0xf852198d0385c4b871e0b91804ecd47c6ba97351"), // sepolia testnet
}
var stickerPackByChainID = map[uint64]common.Address{
1: common.HexToAddress("0x110101156e8F0743948B2A61aFcf3994A8Fb172e"), // mainnet
5: common.HexToAddress("0x8D3fD2EA24bD53a8Bd2b1026727db8bbe9A8C8Af"), // goerli testnet
11155111: common.HexToAddress("0x8cc272396be7583c65bee82cd7b743c69a87287d"), // sepolia testnet
}

21
multiaccounts/accounts/database.go
View File

@ -973,7 +973,7 @@ func (db *Database) updateKeypairClock(tx *sql.Tx, keyUID string, clock uint64)
return err
}
func (db *Database) saveOrUpdateAccounts(tx *sql.Tx, accounts []*Account, updateKeypairClock, isGoerliEnabled bool) (err error) {
func (db *Database) saveOrUpdateAccounts(tx *sql.Tx, accounts []*Account, updateKeypairClock bool) (err error) {
if tx == nil {
return errDbTransactionIsNil
}
@ -1006,11 +1006,7 @@ func (db *Database) saveOrUpdateAccounts(tx *sql.Tx, accounts []*Account, update
}
if acc.TestPreferredChainIDs == "" {
if isGoerliEnabled {
acc.TestPreferredChainIDs = TestPreferredChainIDsDefault
} else {
acc.TestPreferredChainIDs = TestSepoliaPreferredChainIDsDefault
}
acc.TestPreferredChainIDs = TestSepoliaPreferredChainIDsDefault
}
}
@ -1102,10 +1098,6 @@ func (db *Database) SaveOrUpdateAccounts(accounts []*Account, updateKeypairClock
if len(accounts) == 0 {
return errors.New("no provided accounts to save/update")
}
isGoerliEnabled, err := db.GetIsGoerliEnabled()
if err != nil {
return err
}
tx, err := db.db.Begin()
if err != nil {
@ -1118,7 +1110,7 @@ func (db *Database) SaveOrUpdateAccounts(accounts []*Account, updateKeypairClock
}
_ = tx.Rollback()
}()
err = db.saveOrUpdateAccounts(tx, accounts, updateKeypairClock, isGoerliEnabled)
err = db.saveOrUpdateAccounts(tx, accounts, updateKeypairClock)
return err
}
@ -1131,11 +1123,6 @@ func (db *Database) SaveOrUpdateKeypair(keypair *Keypair) error {
return errDbPassedParameterIsNil
}
isGoerliEnabled, err := db.GetIsGoerliEnabled()
if err != nil {
return err
}
tx, err := db.db.Begin()
if err != nil {
return err
@ -1191,7 +1178,7 @@ func (db *Database) SaveOrUpdateKeypair(keypair *Keypair) error {
if err != nil {
return err
}
return db.saveOrUpdateAccounts(tx, keypair.Accounts, false, isGoerliEnabled)
return db.saveOrUpdateAccounts(tx, keypair.Accounts, false)
}
func (db *Database) UpdateKeypairName(keyUID string, name string, clock uint64, updateChatAccountName bool) error {

6
multiaccounts/settings/columns.go
View File

@ -392,11 +392,6 @@ var (
dBColumnName: "test_networks_enabled",
valueHandler: BoolHandler,
}
IsGoerliEnabled = SettingField{
reactFieldName: "is-goerli-enabled?",
dBColumnName: "is_goerli_enabled",
valueHandler: BoolHandler,
}
TokenGroupByCommunity = SettingField{
reactFieldName: "token-group-by-community?",
dBColumnName: "wallet_token_preferences_group_by_community",
@ -532,7 +527,6 @@ var (
GifFavourites,
GifRecents,
HideHomeTooltip,
IsGoerliEnabled,
KeycardInstanceUID,
KeycardPairedOn,
KeycardPairing,

13
multiaccounts/settings/database.go
View File

@ -385,9 +385,9 @@ func (db *Database) GetSettings() (Settings, error) {
profile_pictures_show_to, profile_pictures_visibility, wallet_root_address, wallet_set_up_passed, wallet_visible_tokens,
waku_bloom_filter_mode, webview_allow_permission_requests, current_user_status, send_status_updates, gif_recents,
gif_favorites, opensea_enabled, last_backup, backup_enabled, telemetry_server_url, auto_message_enabled, gif_api_key,
test_networks_enabled, mutual_contact_enabled, profile_migration_needed, is_goerli_enabled, wallet_token_preferences_group_by_community, url_unfurling_mode,
test_networks_enabled, mutual_contact_enabled, profile_migration_needed, wallet_token_preferences_group_by_community, url_unfurling_mode,
mnemonic_was_not_shown, wallet_show_community_asset_when_sending_tokens, wallet_display_assets_below_balance,
wallet_display_assets_below_balance_threshold, wallet_collectible_preferences_group_by_collection, wallet_collectible_preferences_group_by_community,
wallet_display_assets_below_balance_threshold, wallet_collectible_preferences_group_by_collection, wallet_collectible_preferences_group_by_community,
peer_syncing_enabled
FROM
settings
@ -462,7 +462,6 @@ func (db *Database) GetSettings() (Settings, error) {
&s.TestNetworksEnabled,
&s.MutualContactEnabled,
&s.ProfileMigrationNeeded,
&s.IsGoerliEnabled,
&s.TokenGroupByCommunity,
&s.URLUnfurlingMode,
&s.MnemonicWasNotShown,
@ -752,14 +751,6 @@ func (db *Database) GetTestNetworksEnabled() (result bool, err error) {
return result, err
}
func (db *Database) GetIsGoerliEnabled() (result bool, err error) {
err = db.makeSelectRow(IsGoerliEnabled).Scan(&result)
if err == sql.ErrNoRows {
return result, nil
}
return result, err
}
func (db *Database) SetPeerSyncingEnabled(value bool) error {
return db.SaveSettingField(PeerSyncingEnabled, value)
}

1
multiaccounts/settings/database_settings_manager.go
View File

@ -38,7 +38,6 @@ type DatabaseSettingsManager interface {
GetEIP1581Address() (rst types.Address, err error)
GetMasterAddress() (rst types.Address, err error)
GetTestNetworksEnabled() (result bool, err error)
GetIsGoerliEnabled() (result bool, err error)
GetTokenGroupByCommunity() (result bool, err error)
GetCollectibleGroupByCommunity() (result bool, err error)
GetCollectibleGroupByCollection() (result bool, err error)

1
multiaccounts/settings/structs.go
View File

@ -214,7 +214,6 @@ type Settings struct {
GifAPIKey string `json:"gifs/api-key"`
TestNetworksEnabled bool `json:"test-networks-enabled?,omitempty"`
ProfileMigrationNeeded bool `json:"profile-migration-needed,omitempty"`
IsGoerliEnabled bool `json:"is-goerli-enabled?,omitempty"`
TokenGroupByCommunity bool `json:"token-group-by-community?,omitempty"`
ShowCommunityAssetWhenSendingTokens bool `json:"show-community-asset-when-sending-tokens?,omitempty"`
DisplayAssetsBelowBalance bool `json:"display-assets-below-balance?,omitempty"`

2
node/geth_node_test.go
View File

@ -41,7 +41,7 @@ func TestParseNodesToNodeID(t *testing.T) {
}
func TestNewGethNodeConfig(t *testing.T) {
config, err := params.NewNodeConfig("", params.GoerliNetworkID)
config, err := params.NewNodeConfig("", params.SepoliaNetworkID)
require.NoError(t, err)
config.HTTPEnabled = true
config.HTTPVirtualHosts = []string{"my.domain.com"}

4
params/config.go
View File

@ -1184,13 +1184,11 @@ func (c *NodeConfig) AddAPIModule(m string) {
}
// LesTopic returns discovery v5 topic derived from genesis of the provided network.
// 1 - mainnet, 5 - goerli
// 1 - mainnet
func LesTopic(netid int) string {
switch netid {
case 1:
return LESDiscoveryIdentifier + types.Bytes2Hex(params.MainnetGenesisHash.Bytes()[:8])
case 5:
return LESDiscoveryIdentifier + types.Bytes2Hex(params.RinkebyGenesisHash.Bytes()[:8])
default:
return ""
}

6
params/config_test.go
View File

@ -20,7 +20,7 @@ import (
func TestNewNodeConfigWithDefaults(t *testing.T) {
c, err := params.NewNodeConfigWithDefaults(
"/some/data/path",
params.GoerliNetworkID,
params.SepoliaNetworkID,
params.WithFleet(params.FleetProd),
params.WithLES(),
params.WithMailserver(),
@ -87,7 +87,7 @@ func TestNewConfigFromJSON(t *testing.T) {
func TestConfigWriteRead(t *testing.T) {
tmpDir := t.TempDir()
nodeConfig, err := utils.MakeTestNodeConfigWithDataDir("", tmpDir, params.GoerliNetworkID)
nodeConfig, err := utils.MakeTestNodeConfigWithDataDir("", tmpDir, params.SepoliaNetworkID)
require.Nil(t, err, "cannot create new config object")
err = nodeConfig.Save()
@ -96,7 +96,7 @@ func TestConfigWriteRead(t *testing.T) {
loadedConfigData, err := ioutil.ReadFile(filepath.Join(nodeConfig.DataDir, "config.json"))
require.Nil(t, err, "cannot read configuration from disk")
loadedConfig := string(loadedConfigData)
require.Contains(t, loadedConfig, fmt.Sprintf(`"NetworkId": %d`, params.GoerliNetworkID))
require.Contains(t, loadedConfig, fmt.Sprintf(`"NetworkId": %d`, params.SepoliaNetworkID))
require.Contains(t, loadedConfig, fmt.Sprintf(`"DataDir": "%s"`, tmpDir))
}

9
params/defaults.go
View File

@ -60,15 +60,14 @@ const (
// allow us avoid syncing node.
MainnetEthereumNetworkURL = "https://mainnet.infura.io/nKmXgiFgc2KqtoQ8BCGJ"
// GoerliEthereumNetworkURL is an open RPC endpoint to Goerli network
// Other RPC endpoints are available here: http://goerli.blockscout.com/
GoerliEthereumNetworkURL = "http://goerli.blockscout.com/"
// SepoliaEthereumNetworkURL is an open RPC endpoint to Sepolia network
SepoliaEthereumNetworkURL = "https://sepolia.etherscan.io/"
// MainNetworkID is id of the main network
MainNetworkID = 1
// GoerliNetworkID is id of goerli test network (PoA)
GoerliNetworkID = 5
// SepoliaNetworkID is id of sepolia test network
SepoliaNetworkID = 11155111
// StatusChainNetworkID is id of a test network (private chain)
StatusChainNetworkID = 777

4
protocol/messenger_community_for_mobile_testing.go
View File

@ -105,7 +105,7 @@ func (m *Messenger) CreateOpenCommunity() (*MessengerResponse, error) {
func (m *Messenger) CreateTokenGatedCommunity() (*MessengerResponse, error) {
response, err := m.CreateCommunity(&requests.CreateCommunity{
Name: "SNT community",
Description: "require 10 SNT Goerli to use",
Description: "require 10 SNT Sepolia to use",
Color: "#eab700",
HistoryArchiveSupportEnabled: true,
Membership: protobuf.CommunityPermissions_MANUAL_ACCEPT,
@ -122,7 +122,7 @@ func (m *Messenger) CreateTokenGatedCommunity() (*MessengerResponse, error) {
CommunityID: cid,
Type: protobuf.CommunityTokenPermission_BECOME_MEMBER,
TokenCriteria: []*protobuf.TokenCriteria{{
ContractAddresses: map[uint64]string{params.GoerliNetworkID: "0x3D6AFAA395C31FCd391fE3D562E75fe9E8ec7E6a"},
ContractAddresses: map[uint64]string{params.SepoliaNetworkID: "0x3D6AFAA395C31FCd391fE3D562E75fe9E8ec7E6a"},
Type: protobuf.CommunityTokenType_ERC20,
Symbol: "STT",
Name: "Status Test Token",

2
protocol/messenger_curated_communities.go
View File

@ -93,7 +93,7 @@ func (m *Messenger) getCuratedCommunitiesFromContract() (*communities.CuratedCom
chainID := uint64(10) // Optimism Mainnet
if testNetworksEnabled {
chainID = 420 // Optimism Goerli
chainID = 11155420 // Optimism Sepolia
}
directory, err := m.contractMaker.NewDirectory(chainID)

3
protocol/requests/create_account.go
View File

@ -93,13 +93,10 @@ type WalletSecretsConfig struct {
RaribleTestnetAPIKey string `json:"raribleTestnetApiKey"`
AlchemyEthereumMainnetToken string `json:"alchemyEthereumMainnetToken"`
AlchemyEthereumGoerliToken string `json:"alchemyEthereumGoerliToken"`
AlchemyEthereumSepoliaToken string `json:"alchemyEthereumSepoliaToken"`
AlchemyArbitrumMainnetToken string `json:"alchemyArbitrumMainnetToken"`
AlchemyArbitrumGoerliToken string `json:"alchemyArbitrumGoerliToken"`
AlchemyArbitrumSepoliaToken string `json:"alchemyArbitrumSepoliaToken"`
AlchemyOptimismMainnetToken string `json:"alchemyOptimismMainnetToken"`
AlchemyOptimismGoerliToken string `json:"alchemyOptimismGoerliToken"`
AlchemyOptimismSepoliaToken string `json:"alchemyOptimismSepoliaToken"`
StatusProxyStageName string `json:"statusProxyStageName"`

36
rpc/network/network.go
View File

@ -13,8 +13,6 @@ import (
var SepoliaChainIDs = []uint64{11155111, 421614, 11155420}
var GoerliChainIDs = []uint64{5, 421613, 420}
type CombinedNetwork struct {
Prod *params.Network
Test *params.Network
@ -245,11 +243,6 @@ func (nm *Manager) GetAll() ([]*params.Network, error) {
}
func (nm *Manager) Get(onlyEnabled bool) ([]*params.Network, error) {
isGoerliEnabled, err := nm.accountsDB.GetIsGoerliEnabled()
if err != nil {
return nil, err
}
query := newNetworksQuery()
if onlyEnabled {
query.filterEnabled(true)
@ -262,32 +255,6 @@ func (nm *Manager) Get(onlyEnabled bool) ([]*params.Network, error) {
var results []*params.Network
for _, network := range networks {
if isGoerliEnabled {
found := false
for _, chainID := range SepoliaChainIDs {
if network.ChainID == chainID {
found = true
break
}
}
if found {
continue
}
}
if !isGoerliEnabled {
found := false
for _, chainID := range GoerliChainIDs {
if network.ChainID == chainID {
found = true
break
}
}
if found {
continue
}
}
configuredNetwork, err := findNetwork(nm.configuredNetworks, network.ChainID)
if err != nil {
@ -345,8 +312,7 @@ func (nm *Manager) GetTestNetworksEnabled() (result bool, err error) {
return nm.accountsDB.GetTestNetworksEnabled()
}
// Returns all networks for active mode (test/prod) and in case of test mode,
// returns either Goerli or Sepolia networks based on the value of isGoerliEnabled
// Returns all networks for active mode (test/prod)
func (nm *Manager) GetActiveNetworks() ([]*params.Network, error) {
areTestNetworksEnabled, err := nm.GetTestNetworksEnabled()
if err != nil {

8
rpc/network/network_test.go
View File

@ -28,9 +28,9 @@ var initNetworks = []params.Network{
},
{
ChainID: 11155111,
ChainName: "Goerli",
RPCURL: "http://goerli.blockscout.com/",
BlockExplorerURL: "https://goerli.etherscan.io/",
ChainName: "Sepolia",
RPCURL: "https://sepolia.infura.io/v3/",
BlockExplorerURL: "https://sepolia.etherscan.io/",
IconURL: "",
NativeCurrencyName: "Ether",
NativeCurrencySymbol: "ETH",
@ -52,7 +52,7 @@ var initNetworks = []params.Network{
IsTest: false,
Layer: 2,
Enabled: true,
RelatedChainID: 420,
RelatedChainID: 11155420,
},
}

2
services/wallet/activity/activity.go
View File

@ -420,7 +420,7 @@ func getActivityEntries(ctx context.Context, deps FilterDependencies, addresses
networks = joinItems(chainIDs, nil)
}
layer2Chains := []uint64{common.OptimismMainnet, common.OptimismGoerli, common.ArbitrumMainnet, common.ArbitrumGoerli}
layer2Chains := []uint64{common.OptimismMainnet, common.OptimismSepolia, common.ArbitrumMainnet, common.ArbitrumSepolia}
layer2Networks := joinItems(layer2Chains, func(chainID uint64) string {
return fmt.Sprintf("%d", chainID)
})

28
services/wallet/activity/activity_test.go
View File

@ -101,14 +101,14 @@ func setupTestActivityDB(tb testing.TB) (deps FilterDependencies, close func())
}
type testData struct {
tr1 transfer.TestTransfer // index 1, ETH/Goerli
tr1 transfer.TestTransfer // index 1, ETH/Sepolia
pendingTr transfer.TestTransfer // index 2, ETH/Optimism
multiTx1Tr1 transfer.TestTransfer // index 3, USDC/Mainnet
multiTx2Tr1 transfer.TestTransfer // index 4, USDC/Goerli
multiTx2Tr1 transfer.TestTransfer // index 4, USDC/Sepolia
multiTx1Tr2 transfer.TestTransfer // index 5, USDC/Optimism
multiTx2Tr2 transfer.TestTransfer // index 6, SNT/Mainnet
multiTx2PendingTr transfer.TestTransfer // index 7, DAI/Mainnet
multiTx3Tr1 transfer.TestTransfer // index 8, DAI/Goerli
multiTx3Tr1 transfer.TestTransfer // index 8, DAI/Sepolia
multiTx1 transfer.MultiTransaction
multiTx1ID common.MultiTransactionIDType
@ -125,7 +125,7 @@ type testData struct {
// Generates and adds to the DB 8 transfers and 3 multitransactions.
// There are only 5 extractable activity entries (transactions + multi-transactions) with timestamps 1-5. The others are associated with a multi-transaction
func fillTestData(t *testing.T, db *sql.DB) (td testData, fromAddresses, toAddresses []eth.Address) {
// Generates ETH/Goerli, ETH/Optimism, USDC/Mainnet, USDC/Goerli, USDC/Optimism, SNT/Mainnet, DAI/Mainnet, DAI/Goerli
// Generates ETH/Sepolia, ETH/Optimism, USDC/Mainnet, USDC/Sepolia, USDC/Optimism, SNT/Mainnet, DAI/Mainnet, DAI/Sepolia
trs, fromAddresses, toAddresses := transfer.GenerateTestTransfers(t, db, 1, 8)
// Plain transfer
@ -1016,9 +1016,9 @@ func TestGetActivityEntriesFilterByTokenType(t *testing.T) {
deps, close := setupTestActivityDB(t)
defer close()
// Adds 4 extractable transactions 2 transactions (ETH/Goerli, ETH/Optimism), one MT USDC to DAI and another MT USDC to SNT
// Adds 4 extractable transactions 2 transactions (ETH/Sepolia, ETH/Optimism), one MT USDC to DAI and another MT USDC to SNT
td, fromTds, toTds := fillTestData(t, deps.db)
// Add 9 transactions DAI/Goerli, ETH/Mainnet, ETH/Goerli, ETH/Optimism, USDC/Mainnet, USDC/Goerli, USDC/Optimism, SNT/Mainnet, DAI/Mainnet
// Add 9 transactions DAI/Sepolia, ETH/Mainnet, ETH/Sepolia, ETH/Optimism, USDC/Mainnet, USDC/Sepolia, USDC/Optimism, SNT/Mainnet, DAI/Mainnet
trs, fromTrs, toTrs := transfer.GenerateTestTransfers(t, deps.db, td.nextIndex, 9)
for i := range trs {
tokenAddr := transfer.TestTokens[i].Address
@ -1061,7 +1061,7 @@ func TestGetActivityEntriesFilterByTokenType(t *testing.T) {
}}
entries, err = getActivityEntries(context.Background(), deps, allAddresses, true, []common.ChainID{}, filter, 0, 15)
require.NoError(t, err)
// Three MT for which ChainID is ignored and one transfer on the main net and the Goerli is ignored
// Three MT for which ChainID is ignored and one transfer on the main net and the Sepolia is ignored
require.Equal(t, 4, len(entries))
require.Equal(t, Erc20, entries[0].tokenIn.TokenType)
require.Equal(t, transfer.UsdcMainnet.Address, entries[0].tokenIn.Address)
@ -1084,15 +1084,15 @@ func TestGetActivityEntriesFilterByTokenType(t *testing.T) {
Address: transfer.UsdcMainnet.Address,
}, {
TokenType: Erc20,
ChainID: common.ChainID(transfer.UsdcGoerli.ChainID),
Address: transfer.UsdcGoerli.Address,
ChainID: common.ChainID(transfer.UsdcSepolia.ChainID),
Address: transfer.UsdcSepolia.Address,
}}
entries, err = getActivityEntries(context.Background(), deps, allAddresses, true, []common.ChainID{}, filter, 0, 15)
require.NoError(t, err)
// Three MT for which ChainID is ignored and two transfers on the main net and Goerli
// Three MT for which ChainID is ignored and two transfers on the main net and Sepolia
require.Equal(t, 5, len(entries))
require.Equal(t, Erc20, entries[0].tokenIn.TokenType)
require.Equal(t, transfer.UsdcGoerli.Address, entries[0].tokenIn.Address)
require.Equal(t, transfer.UsdcSepolia.Address, entries[0].tokenIn.Address)
require.Nil(t, entries[0].tokenOut)
}
@ -1100,7 +1100,7 @@ func TestGetActivityEntriesFilterByCollectibles(t *testing.T) {
deps, close := setupTestActivityDB(t)
defer close()
// Adds 4 extractable transactions 2 transactions (ETH/Goerli, ETH/Optimism), one MT USDC to DAI and another MT USDC to SNT
// Adds 4 extractable transactions 2 transactions (ETH/Sepolia, ETH/Optimism), one MT USDC to DAI and another MT USDC to SNT
td, fromTds, toTds := fillTestData(t, deps.db)
// Add 4 transactions with collectibles
trs, fromTrs, toTrs := transfer.GenerateTestTransfers(t, deps.db, td.nextIndex, 4)
@ -1400,7 +1400,7 @@ func TestGetTxDetails(t *testing.T) {
deps, close := setupTestActivityDB(t)
defer close()
// Adds 4 extractable transactions 2 transactions (ETH/Goerli, ETH/Optimism), one MT USDC to DAI and another MT USDC to SNT
// Adds 4 extractable transactions 2 transactions (ETH/Sepolia, ETH/Optimism), one MT USDC to DAI and another MT USDC to SNT
td, _, _ := fillTestData(t, deps.db)
_, err := getTxDetails(context.Background(), deps.db, "")
@ -1423,7 +1423,7 @@ func TestGetMultiTxDetails(t *testing.T) {
deps, close := setupTestActivityDB(t)
defer close()
// Adds 4 extractable transactions 2 transactions (ETH/Goerli, ETH/Optimism), one MT USDC to DAI and another MT USDC to SNT
// Adds 4 extractable transactions 2 transactions (ETH/Sepolia, ETH/Optimism), one MT USDC to DAI and another MT USDC to SNT
td, _, _ := fillTestData(t, deps.db)
_, err := getMultiTxDetails(context.Background(), deps.db, 0)

2
services/wallet/collectibles/controller.go
View File

@ -366,7 +366,7 @@ func (c *Controller) startSettingsWatcher() {
}
settingChangeCb := func(setting settings.SettingField, value interface{}) {
if setting.Equals(settings.TestNetworksEnabled) || setting.Equals(settings.IsGoerliEnabled) {
if setting.Equals(settings.TestNetworksEnabled) {
c.stopPeriodicalOwnershipFetch()
err := c.startPeriodicalOwnershipFetch()
if err != nil {

11
services/wallet/common/const.go
View File

@ -20,13 +20,10 @@ type ChainID uint64
const (
UnknownChainID uint64 = 0
EthereumMainnet uint64 = 1
EthereumGoerli uint64 = 5
EthereumSepolia uint64 = 11155111
OptimismMainnet uint64 = 10
OptimismGoerli uint64 = 420
OptimismSepolia uint64 = 11155420
ArbitrumMainnet uint64 = 42161
ArbitrumGoerli uint64 = 421613
ArbitrumSepolia uint64 = 421614
BinanceChainID uint64 = 56 // obsolete?
BinanceTestChainID uint64 = 97 // obsolete?
@ -76,7 +73,7 @@ func (c ChainID) IsMainnet() bool {
switch uint64(c) {
case EthereumMainnet, OptimismMainnet, ArbitrumMainnet:
return true
case EthereumGoerli, EthereumSepolia, OptimismGoerli, OptimismSepolia, ArbitrumGoerli, ArbitrumSepolia:
case EthereumSepolia, OptimismSepolia, ArbitrumSepolia:
return false
case UnknownChainID:
return false
@ -87,13 +84,10 @@ func (c ChainID) IsMainnet() bool {
func AllChainIDs() []ChainID {
return []ChainID{
ChainID(EthereumMainnet),
ChainID(EthereumGoerli),
ChainID(EthereumSepolia),
ChainID(OptimismMainnet),
ChainID(OptimismGoerli),
ChainID(OptimismSepolia),
ChainID(ArbitrumMainnet),
ChainID(ArbitrumGoerli),
ChainID(ArbitrumSepolia),
}
}
@ -101,9 +95,6 @@ func AllChainIDs() []ChainID {
var AverageBlockDurationForChain = map[ChainID]time.Duration{
ChainID(UnknownChainID): time.Duration(12000) * time.Millisecond,
ChainID(EthereumMainnet): time.Duration(12000) * time.Millisecond,
ChainID(EthereumGoerli): time.Duration(12000) * time.Millisecond,
ChainID(OptimismMainnet): time.Duration(400) * time.Millisecond,
ChainID(OptimismGoerli): time.Duration(2000) * time.Millisecond,
ChainID(ArbitrumMainnet): time.Duration(300) * time.Millisecond,
ChainID(ArbitrumGoerli): time.Duration(1500) * time.Millisecond,
}

2
services/wallet/history/service.go
View File

@ -446,7 +446,7 @@ func (s *Service) addEntriesToDB(ctx context.Context, client chain.ClientInterfa
if token == nil {
log.Warn("Token not found", "chainID", network.ChainID, "address", address.String(), "tokenAddress", entry.tokenAddress.String())
// TODO Add "supported=false" flag to such tokens to avoid checking them again and again
continue // Skip token that we don't have symbol for. For example we don't have tokens in store for goerli optimism
continue // Skip token that we don't have symbol for. For example we don't have tokens in store for sepolia optimism
} else {
entry.tokenSymbol = token.Symbol
}

6
services/wallet/router/fees/fees.go
View File

@ -160,10 +160,6 @@ func (f *FeeManager) getBaseFee(ctx context.Context, client chain.ClientInterfac
common.OptimismSepolia,
common.ArbitrumSepolia:
config = params.SepoliaChainConfig
case common.EthereumGoerli,
common.OptimismGoerli,
common.ArbitrumGoerli:
config = params.GoerliChainConfig
}
baseFee := misc.CalcBaseFee(config, header)
return baseFee, nil
@ -263,7 +259,7 @@ func (f *FeeManager) getFeeHistorySorted(chainID uint64) ([]*big.Int, error) {
// Returns L1 fee for placing a transaction to L1 chain, appicable only for txs made from L2.
func (f *FeeManager) GetL1Fee(ctx context.Context, chainID uint64, input []byte) (uint64, error) {
if chainID == common.EthereumMainnet || chainID == common.EthereumSepolia && chainID != common.EthereumGoerli {
if chainID == common.EthereumMainnet || chainID == common.EthereumSepolia {
return 0, nil
}

1
services/wallet/router/sendtype/send_type.go
View File

@ -155,7 +155,6 @@ func (s SendType) IsAvailableFor(network *params.Network) bool {
// Set of network ChainIDs allowed for any type of transaction
allAllowedNetworks := map[uint64]bool{
walletCommon.EthereumMainnet: true,
walletCommon.EthereumGoerli: true,
walletCommon.EthereumSepolia: true,
}

4
services/wallet/thirdparty/alchemy/client.go vendored
View File

@ -27,8 +27,6 @@ func getBaseURL(chainID walletCommon.ChainID) (string, error) {
switch uint64(chainID) {
case walletCommon.EthereumMainnet:
return "https://eth-mainnet.g.alchemy.com", nil
case walletCommon.EthereumGoerli:
return "https://eth-goerli.g.alchemy.com", nil
case walletCommon.EthereumSepolia:
return "https://eth-sepolia.g.alchemy.com", nil
case walletCommon.OptimismMainnet:
@ -37,8 +35,6 @@ func getBaseURL(chainID walletCommon.ChainID) (string, error) {
return "https://opt-sepolia.g.alchemy.com", nil
case walletCommon.ArbitrumMainnet:
return "https://arb-mainnet.g.alchemy.com", nil
case walletCommon.ArbitrumGoerli:
return "https://arb-goerli.g.alchemy.com", nil
case walletCommon.ArbitrumSepolia:
return "https://arb-sepolia.g.alchemy.com", nil
}

9
services/wallet/transfer/commands.go
View File

@ -48,9 +48,6 @@ var (
// This will work only for binance testnet as mainnet doesn't support
// archival request.
binanceChainErc20BatchSize = big.NewInt(5000)
goerliErc20BatchSize = big.NewInt(100000)
goerliErc20ArbitrumBatchSize = big.NewInt(10000)
goerliErc20OptimismBatchSize = big.NewInt(10000)
sepoliaErc20BatchSize = big.NewInt(100000)
sepoliaErc20ArbitrumBatchSize = big.NewInt(10000)
sepoliaErc20OptimismBatchSize = big.NewInt(10000)
@ -139,12 +136,6 @@ func getErc20BatchSize(chainID uint64) *big.Int {
return sepoliaErc20OptimismBatchSize
case w_common.ArbitrumSepolia:
return sepoliaErc20ArbitrumBatchSize
case w_common.EthereumGoerli:
return goerliErc20BatchSize
case w_common.OptimismGoerli:
return goerliErc20OptimismBatchSize
case w_common.ArbitrumGoerli:
return goerliErc20ArbitrumBatchSize
case w_common.BinanceChainID:
return binanceChainErc20BatchSize
case w_common.BinanceTestChainID:

30
services/wallet/transfer/testutils.go
View File

@ -215,11 +215,11 @@ var EthMainnet = token.Token{
ChainID: 1,
}
var EthGoerli = token.Token{
var EthSepolia = token.Token{
Address: eth_common.HexToAddress("0x"),
Name: "Ether",
Symbol: "ETH",
ChainID: 5,
ChainID: 11155111,
}
var EthOptimism = token.Token{
@ -236,11 +236,12 @@ var UsdcMainnet = token.Token{
ChainID: 1,
}
var UsdcGoerli = token.Token{
Address: eth_common.HexToAddress("0x98339d8c260052b7ad81c28c16c0b98420f2b46a"),
Name: "USD Coin",
Symbol: "USDC",
ChainID: 5,
var UsdcSepolia = token.Token{
Address: eth_common.HexToAddress("0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"),
Name: "USD Coin",
Symbol: "USDC",
Decimals: 6,
ChainID: 11155111,
}
var UsdcOptimism = token.Token{
@ -264,16 +265,17 @@ var DaiMainnet = token.Token{
ChainID: 5,
}
var DaiGoerli = token.Token{
Address: eth_common.HexToAddress("0xf2edF1c091f683E3fb452497d9a98A49cBA84666"),
Name: "DAI Stablecoin",
Symbol: "DAI",
ChainID: 5,
var DaiSepolia = token.Token{
Address: eth_common.HexToAddress("0x3e622317f8c93f7328350cf0b56d9ed4c620c5d6"),
Name: "DAI Stablecoin",
Symbol: "DAI",
Decimals: 18,
ChainID: 11155111,
}
// TestTokens contains ETH/Mainnet, ETH/Goerli, ETH/Optimism, USDC/Mainnet, USDC/Goerli, USDC/Optimism, SNT/Mainnet, DAI/Mainnet, DAI/Goerli
// TestTokens contains ETH/Mainnet, ETH/Sepolia, ETH/Optimism, USDC/Mainnet, USDC/Sepolia, USDC/Optimism, SNT/Mainnet, DAI/Mainnet, DAI/Sepolia
var TestTokens = []*token.Token{
&EthMainnet, &EthGoerli, &EthOptimism, &UsdcMainnet, &UsdcGoerli, &UsdcOptimism, &SntMainnet, &DaiMainnet, &DaiGoerli,
&EthMainnet, &EthSepolia, &EthOptimism, &UsdcMainnet, &UsdcSepolia, &UsdcOptimism, &SntMainnet, &DaiMainnet, &DaiSepolia,
}
func LookupTokenIdentity(chainID uint64, address eth_common.Address, native bool) *token.Token {

14
t/utils/utils.go
View File

@ -52,7 +52,7 @@ var (
TestNetworkNames = map[int]string{
params.MainNetworkID: "Mainnet",
params.StatusChainNetworkID: "StatusChain",
params.GoerliNetworkID: "Goerli",
params.SepoliaNetworkID: "Sepolia",
}
syncTimeout = 50 * time.Minute
@ -127,8 +127,8 @@ func GetRemoteURLFromNetworkID(id int) (url string, err error) {
switch id {
case params.MainNetworkID:
url = params.MainnetEthereumNetworkURL
case params.GoerliNetworkID:
url = params.GoerliEthereumNetworkURL
case params.SepoliaNetworkID:
url = params.SepoliaEthereumNetworkURL
default:
err = ErrNoRemoteURL
}
@ -143,8 +143,8 @@ func GetHeadHashFromNetworkID(id int) string {
return "0xd4e56740f876aef8c010b86a40d5f56745a118d0906a34e69aec8c0db1cb8fa3"
case params.StatusChainNetworkID:
return "0xe9d8920a99dc66a9557a87d51f9d14a34ec50aae04298e0f142187427d3c832e"
case params.GoerliNetworkID:
return "0xbf7e331f7f7c1dd2e05159666b3bf8bc7a8a3a9eb1d518969eab529dd9b88c1a"
case params.SepoliaNetworkID:
return "0x25a5cc106eea7138acab33231d7160d69cb777ee0c2c553fcddf5138993e6dd9"
}
// Every other ID must break the test.
panic(fmt.Sprintf("invalid network id: %d", id))
@ -168,8 +168,8 @@ func GetNetworkID() int {
return params.MainNetworkID
case fmt.Sprintf("%d", params.StatusChainNetworkID), "statuschain":
return params.StatusChainNetworkID
case fmt.Sprintf("%d", params.GoerliNetworkID), "goerli":
return params.GoerliNetworkID
case fmt.Sprintf("%d", params.SepoliaNetworkID), "sepolia":
return params.SepoliaNetworkID
}
// Every other selected network must break the test.
panic(fmt.Sprintf("invalid selected network: %q", *networkSelected))

3
transactions/transactor.go
View File

@ -110,8 +110,7 @@ func (t *Transactor) NextNonce(rpcClient rpc.ClientInterface, chainID uint64, fr
// We need to take into consideration all pending transactions in case of Optimism, cause the network returns always
// the nonce of last executed tx + 1 for the next nonce value.
if chainID == wallet_common.OptimismMainnet ||
chainID == wallet_common.OptimismSepolia ||
chainID == wallet_common.OptimismGoerli {
chainID == wallet_common.OptimismSepolia {
if t.pendingTracker != nil {
countOfPendingTXs, err := t.pendingTracker.CountPendingTxsFromNonce(wallet_common.ChainID(chainID), common.Address(from), nonce)
if err != nil {