status-go/rpc/network/network.go

305 lines
8.2 KiB
Go
Raw Normal View History

package network
import (
"bytes"
"database/sql"
"fmt"
2023-10-03 13:27:42 +00:00
"github.com/status-im/status-go/multiaccounts/accounts"
"github.com/status-im/status-go/params"
)
2023-10-10 12:30:12 +00:00
var SepoliaChainIDs = []uint64{11155111, 421614}
2023-10-03 13:27:42 +00:00
// GoerliChainIDs Uncomment next chain when we move more chain to sepolia
2023-10-10 12:30:12 +00:00
var GoerliChainIDs = []uint64{5, 421613} //, 420, }
2023-10-03 13:27:42 +00:00
type CombinedNetwork struct {
Prod *params.Network
Test *params.Network
}
2023-09-15 08:06:44 +00:00
const baseQuery = "SELECT chain_id, chain_name, rpc_url, original_rpc_url, fallback_url, original_fallback_url, block_explorer_url, icon_url, native_currency_name, native_currency_symbol, native_currency_decimals, is_test, layer, enabled, chain_color, short_name, related_chain_id FROM networks"
func newNetworksQuery() *networksQuery {
buf := bytes.NewBuffer(nil)
buf.WriteString(baseQuery)
return &networksQuery{buf: buf}
}
type networksQuery struct {
buf *bytes.Buffer
args []interface{}
added bool
}
func (nq *networksQuery) andOrWhere() {
if nq.added {
nq.buf.WriteString(" AND")
} else {
nq.buf.WriteString(" WHERE")
}
}
func (nq *networksQuery) filterEnabled(enabled bool) *networksQuery {
nq.andOrWhere()
nq.added = true
nq.buf.WriteString(" enabled = ?")
nq.args = append(nq.args, enabled)
return nq
}
func (nq *networksQuery) filterChainID(chainID uint64) *networksQuery {
nq.andOrWhere()
nq.added = true
nq.buf.WriteString(" chain_id = ?")
nq.args = append(nq.args, chainID)
return nq
}
2023-09-15 08:06:44 +00:00
func (nq *networksQuery) exec(db *sql.DB) ([]*params.Network, error) {
rows, err := db.Query(nq.buf.String(), nq.args...)
if err != nil {
return nil, err
}
var res []*params.Network
defer rows.Close()
for rows.Next() {
network := params.Network{}
err := rows.Scan(
2023-09-15 08:06:44 +00:00
&network.ChainID, &network.ChainName, &network.RPCURL, &network.OriginalRPCURL, &network.FallbackURL, &network.OriginalFallbackURL,
&network.BlockExplorerURL, &network.IconURL, &network.NativeCurrencyName, &network.NativeCurrencySymbol,
&network.NativeCurrencyDecimals, &network.IsTest, &network.Layer, &network.Enabled, &network.ChainColor, &network.ShortName,
&network.RelatedChainID,
)
if err != nil {
return nil, err
}
2023-08-08 09:05:17 +00:00
res = append(res, &network)
}
return res, err
}
type Manager struct {
2023-08-08 09:05:17 +00:00
db *sql.DB
configuredNetworks []params.Network
2023-10-03 13:27:42 +00:00
accountsDB *accounts.Database
}
func NewManager(db *sql.DB) *Manager {
2023-10-03 13:27:42 +00:00
accountsDB, err := accounts.NewDB(db)
if err != nil {
return nil
}
return &Manager{
2023-10-03 13:27:42 +00:00
db: db,
accountsDB: accountsDB,
}
}
func find(chainID uint64, networks []params.Network) int {
for i := range networks {
if networks[i].ChainID == chainID {
return i
}
}
return -1
}
func (nm *Manager) Init(networks []params.Network) error {
if networks == nil {
return nil
}
2023-08-08 09:05:17 +00:00
nm.configuredNetworks = networks
var errors string
currentNetworks, _ := nm.Get(false)
// Delete networks which are not supported any more
for i := range currentNetworks {
if find(currentNetworks[i].ChainID, networks) == -1 {
err := nm.Delete(currentNetworks[i].ChainID)
if err != nil {
errors += fmt.Sprintf("error deleting network with ChainID: %d, %s", currentNetworks[i].ChainID, err.Error())
}
}
}
2023-08-08 09:05:17 +00:00
// Add new networks and update related chain id for the old ones
for i := range networks {
found := false
// Update original urls if they are empty
if networks[i].OriginalRPCURL == "" {
networks[i].OriginalRPCURL = networks[i].RPCURL
}
if networks[i].OriginalFallbackURL == "" {
networks[i].OriginalFallbackURL = networks[i].FallbackURL
}
for j := range currentNetworks {
if currentNetworks[j].ChainID == networks[i].ChainID {
found = true
if currentNetworks[j].RelatedChainID != networks[i].RelatedChainID {
// Update fallback_url if it's different
err := nm.UpdateRelatedChainID(currentNetworks[j].ChainID, networks[i].RelatedChainID)
if err != nil {
errors += fmt.Sprintf("error updating network fallback_url for ChainID: %d, %s", currentNetworks[j].ChainID, err.Error())
}
}
err := nm.UpdateRPCURLs(currentNetworks[j].ChainID, networks[i].RPCURL, networks[i].OriginalRPCURL, networks[i].FallbackURL, networks[i].OriginalFallbackURL)
2023-09-15 08:06:44 +00:00
if err != nil {
errors += fmt.Sprintf("error updating network original url for ChainID: %d, %s", currentNetworks[j].ChainID, err.Error())
}
break
}
}
if !found {
// Insert new network
err := nm.Upsert(&networks[i])
if err != nil {
errors += fmt.Sprintf("error inserting network with ChainID: %d, %s", networks[i].ChainID, err.Error())
}
}
}
if len(errors) > 0 {
return fmt.Errorf(errors)
}
return nil
}
func (nm *Manager) Upsert(network *params.Network) error {
_, err := nm.db.Exec(
2023-09-15 08:06:44 +00:00
"INSERT OR REPLACE INTO networks (chain_id, chain_name, rpc_url, original_rpc_url, fallback_url, original_fallback_url, block_explorer_url, icon_url, native_currency_name, native_currency_symbol, native_currency_decimals, is_test, layer, enabled, chain_color, short_name, related_chain_id) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)",
network.ChainID, network.ChainName, network.RPCURL, network.OriginalRPCURL, network.FallbackURL, network.OriginalFallbackURL, network.BlockExplorerURL, network.IconURL,
network.NativeCurrencyName, network.NativeCurrencySymbol, network.NativeCurrencyDecimals,
network.IsTest, network.Layer, network.Enabled, network.ChainColor, network.ShortName,
network.RelatedChainID,
)
return err
}
func (nm *Manager) Delete(chainID uint64) error {
_, err := nm.db.Exec("DELETE FROM networks WHERE chain_id = ?", chainID)
return err
}
func (nm *Manager) UpdateRelatedChainID(chainID uint64, relatedChainID uint64) error {
_, err := nm.db.Exec(`UPDATE networks SET related_chain_id = ? WHERE chain_id = ?`, relatedChainID, chainID)
return err
}
func (nm *Manager) UpdateRPCURLs(chainID uint64, rpcURL, originalRPCURL, fallbackURL, originalFallbackURL string) error {
_, err := nm.db.Exec(`UPDATE networks SET rpc_url = ?, original_rpc_url = ?, fallback_url = ?, original_fallback_url = ? WHERE chain_id = ?`,
rpcURL, originalRPCURL, fallbackURL, originalFallbackURL, chainID)
2023-09-15 08:06:44 +00:00
return err
}
func (nm *Manager) Find(chainID uint64) *params.Network {
2023-09-15 08:06:44 +00:00
networks, err := newNetworksQuery().filterChainID(chainID).exec(nm.db)
if len(networks) != 1 || err != nil {
return nil
}
return networks[0]
}
2023-10-03 13:27:42 +00:00
func (nm *Manager) GetAll() ([]*params.Network, error) {
query := newNetworksQuery()
return query.exec(nm.db)
}
func (nm *Manager) Get(onlyEnabled bool) ([]*params.Network, error) {
2023-10-03 13:27:42 +00:00
isSepoliaEnabled, err := nm.accountsDB.GetIsSepoliaEnabled()
if err != nil {
return nil, err
}
query := newNetworksQuery()
if onlyEnabled {
query.filterEnabled(true)
}
2023-10-03 13:27:42 +00:00
networks, err := query.exec(nm.db)
if err != nil {
return nil, err
}
var results []*params.Network
for _, network := range networks {
2023-10-10 12:30:12 +00:00
if !isSepoliaEnabled {
found := false
for _, chainID := range SepoliaChainIDs {
if network.ChainID == chainID {
found = true
break
}
}
if found {
continue
}
2023-10-03 13:27:42 +00:00
}
if isSepoliaEnabled {
found := false
for _, chainID := range GoerliChainIDs {
if network.ChainID == chainID {
found = true
break
}
}
if found {
continue
}
}
results = append(results, network)
}
return results, nil
}
func (nm *Manager) GetCombinedNetworks() ([]*CombinedNetwork, error) {
2023-10-03 13:27:42 +00:00
networks, err := nm.Get(false)
if err != nil {
return nil, err
}
var combinedNetworks []*CombinedNetwork
for _, network := range networks {
found := false
for _, n := range combinedNetworks {
2023-10-03 13:27:42 +00:00
if (n.Test != nil && (network.ChainID == n.Test.RelatedChainID || n.Test.ChainID == network.RelatedChainID)) || (n.Prod != nil && (network.ChainID == n.Prod.RelatedChainID || n.Prod.ChainID == network.RelatedChainID)) {
found = true
if network.IsTest {
n.Test = network
break
} else {
n.Prod = network
break
}
}
}
if found {
continue
}
newCombined := &CombinedNetwork{}
if network.IsTest {
newCombined.Test = network
} else {
newCombined.Prod = network
}
combinedNetworks = append(combinedNetworks, newCombined)
}
return combinedNetworks, nil
}
func (nm *Manager) GetConfiguredNetworks() []params.Network {
2023-08-08 09:05:17 +00:00
return nm.configuredNetworks
}