408 lines
13 KiB
Go
408 lines
13 KiB
Go
package wallet
|
|
|
|
import (
|
|
"database/sql"
|
|
"encoding/json"
|
|
"fmt"
|
|
"sync"
|
|
"time"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/event"
|
|
"github.com/ethereum/go-ethereum/p2p"
|
|
gethrpc "github.com/ethereum/go-ethereum/rpc"
|
|
|
|
"github.com/status-im/status-go/account"
|
|
"github.com/status-im/status-go/logutils"
|
|
"github.com/status-im/status-go/multiaccounts/accounts"
|
|
"github.com/status-im/status-go/params"
|
|
protocolCommon "github.com/status-im/status-go/protocol/common"
|
|
"github.com/status-im/status-go/rpc"
|
|
"github.com/status-im/status-go/server"
|
|
"github.com/status-im/status-go/services/ens/ensresolver"
|
|
"github.com/status-im/status-go/services/wallet/activity"
|
|
"github.com/status-im/status-go/services/wallet/balance"
|
|
"github.com/status-im/status-go/services/wallet/blockchainstate"
|
|
"github.com/status-im/status-go/services/wallet/collectibles"
|
|
"github.com/status-im/status-go/services/wallet/community"
|
|
"github.com/status-im/status-go/services/wallet/currency"
|
|
"github.com/status-im/status-go/services/wallet/history"
|
|
"github.com/status-im/status-go/services/wallet/market"
|
|
"github.com/status-im/status-go/services/wallet/onramp"
|
|
"github.com/status-im/status-go/services/wallet/routeexecution"
|
|
"github.com/status-im/status-go/services/wallet/router"
|
|
"github.com/status-im/status-go/services/wallet/router/pathprocessor"
|
|
"github.com/status-im/status-go/services/wallet/thirdparty"
|
|
"github.com/status-im/status-go/services/wallet/thirdparty/alchemy"
|
|
"github.com/status-im/status-go/services/wallet/thirdparty/coingecko"
|
|
"github.com/status-im/status-go/services/wallet/thirdparty/cryptocompare"
|
|
"github.com/status-im/status-go/services/wallet/thirdparty/opensea"
|
|
"github.com/status-im/status-go/services/wallet/thirdparty/rarible"
|
|
"github.com/status-im/status-go/services/wallet/token"
|
|
"github.com/status-im/status-go/services/wallet/transfer"
|
|
"github.com/status-im/status-go/services/wallet/walletevent"
|
|
"github.com/status-im/status-go/transactions"
|
|
)
|
|
|
|
const (
|
|
EventBlockchainStatusChanged walletevent.EventType = "wallet-blockchain-status-changed"
|
|
)
|
|
|
|
// NewService initializes service instance.
|
|
func NewService(
|
|
db *sql.DB,
|
|
accountsDB *accounts.Database,
|
|
appDB *sql.DB,
|
|
rpcClient *rpc.Client,
|
|
accountFeed *event.Feed,
|
|
settingsFeed *event.Feed,
|
|
gethManager *account.GethManager,
|
|
transactor *transactions.Transactor,
|
|
config *params.NodeConfig,
|
|
ensResolver *ensresolver.EnsResolver,
|
|
pendingTxManager *transactions.PendingTxTracker,
|
|
feed *event.Feed,
|
|
mediaServer *server.MediaServer,
|
|
statusProxyStageName string,
|
|
) *Service {
|
|
signals := &walletevent.SignalsTransmitter{
|
|
Publisher: feed,
|
|
}
|
|
blockchainStatus := make(map[uint64]string)
|
|
mutex := sync.Mutex{}
|
|
rpcClient.SetWalletNotifier(func(chainID uint64, message string) {
|
|
mutex.Lock()
|
|
defer mutex.Unlock()
|
|
|
|
if len(blockchainStatus) == 0 {
|
|
networks, err := rpcClient.NetworkManager.Get(false)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
for _, network := range networks {
|
|
blockchainStatus[network.ChainID] = "up"
|
|
}
|
|
}
|
|
|
|
blockchainStatus[chainID] = message
|
|
encodedmessage, err := json.Marshal(blockchainStatus)
|
|
if err != nil {
|
|
return
|
|
}
|
|
|
|
feed.Send(walletevent.Event{
|
|
Type: EventBlockchainStatusChanged,
|
|
Accounts: []common.Address{},
|
|
Message: string(encodedmessage),
|
|
At: time.Now().Unix(),
|
|
ChainID: chainID,
|
|
})
|
|
})
|
|
|
|
communityManager := community.NewManager(db, mediaServer, feed)
|
|
balanceCacher := balance.NewCacherWithTTL(5 * time.Minute)
|
|
tokenManager := token.NewTokenManager(db, rpcClient, communityManager, rpcClient.NetworkManager, appDB, mediaServer, feed, accountFeed, accountsDB, token.NewPersistence(db))
|
|
tokenManager.Start()
|
|
|
|
cryptoOnRampProviders := []onramp.Provider{
|
|
onramp.NewRampProvider(),
|
|
onramp.NewMoonPayProvider(),
|
|
}
|
|
|
|
featureFlags := &protocolCommon.FeatureFlags{}
|
|
if config.WalletConfig.EnableCelerBridge {
|
|
featureFlags.EnableCelerBridge = true
|
|
}
|
|
|
|
if config.WalletConfig.EnableMercuryoProvider {
|
|
featureFlags.EnableMercuryoProvider = true
|
|
}
|
|
|
|
if featureFlags.EnableMercuryoProvider {
|
|
cryptoOnRampProviders = append(cryptoOnRampProviders, onramp.NewMercuryoProvider(tokenManager))
|
|
}
|
|
|
|
cryptoOnRampManager := onramp.NewManager(cryptoOnRampProviders)
|
|
|
|
savedAddressesManager := &SavedAddressesManager{db: db}
|
|
transactionManager := transfer.NewTransactionManager(transfer.NewMultiTransactionDB(db), gethManager, transactor, config, accountsDB, pendingTxManager, feed)
|
|
blockChainState := blockchainstate.NewBlockChainState()
|
|
transferController := transfer.NewTransferController(db, accountsDB, rpcClient, accountFeed, feed, transactionManager, pendingTxManager,
|
|
tokenManager, balanceCacher, blockChainState)
|
|
transferController.Start()
|
|
cryptoCompare := cryptocompare.NewClient()
|
|
coingecko := coingecko.NewClient()
|
|
cryptoCompareProxy := cryptocompare.NewClientWithParams(cryptocompare.Params{
|
|
ID: fmt.Sprintf("%s-proxy", cryptoCompare.ID()),
|
|
URL: fmt.Sprintf("https://%s.api.status.im/cryptocompare/", statusProxyStageName),
|
|
User: config.WalletConfig.StatusProxyMarketUser,
|
|
Password: config.WalletConfig.StatusProxyMarketPassword,
|
|
})
|
|
marketManager := market.NewManager([]thirdparty.MarketDataProvider{cryptoCompare, coingecko, cryptoCompareProxy}, feed)
|
|
reader := NewReader(tokenManager, marketManager, token.NewPersistence(db), feed)
|
|
history := history.NewService(db, accountsDB, accountFeed, feed, rpcClient, tokenManager, marketManager, balanceCacher.Cache())
|
|
currency := currency.NewService(db, feed, tokenManager, marketManager)
|
|
|
|
openseaHTTPClient := opensea.NewHTTPClient()
|
|
openseaV2Client := opensea.NewClientV2(config.WalletConfig.OpenseaAPIKey, openseaHTTPClient)
|
|
raribleClient := rarible.NewClient(config.WalletConfig.RaribleMainnetAPIKey, config.WalletConfig.RaribleTestnetAPIKey)
|
|
alchemyClient := alchemy.NewClient(config.WalletConfig.AlchemyAPIKeys)
|
|
|
|
// Collectible providers in priority order (i.e. provider N+1 will be tried only if provider N fails)
|
|
contractOwnershipProviders := []thirdparty.CollectibleContractOwnershipProvider{
|
|
raribleClient,
|
|
alchemyClient,
|
|
}
|
|
|
|
accountOwnershipProviders := []thirdparty.CollectibleAccountOwnershipProvider{
|
|
raribleClient,
|
|
alchemyClient,
|
|
openseaV2Client,
|
|
}
|
|
|
|
collectibleDataProviders := []thirdparty.CollectibleDataProvider{
|
|
raribleClient,
|
|
alchemyClient,
|
|
openseaV2Client,
|
|
}
|
|
|
|
collectionDataProviders := []thirdparty.CollectionDataProvider{
|
|
raribleClient,
|
|
alchemyClient,
|
|
openseaV2Client,
|
|
}
|
|
|
|
collectibleSearchProviders := []thirdparty.CollectibleSearchProvider{
|
|
raribleClient,
|
|
}
|
|
|
|
collectibleProviders := thirdparty.CollectibleProviders{
|
|
ContractOwnershipProviders: contractOwnershipProviders,
|
|
AccountOwnershipProviders: accountOwnershipProviders,
|
|
CollectibleDataProviders: collectibleDataProviders,
|
|
CollectionDataProviders: collectionDataProviders,
|
|
SearchProviders: collectibleSearchProviders,
|
|
}
|
|
|
|
collectiblesManager := collectibles.NewManager(
|
|
db,
|
|
rpcClient,
|
|
communityManager,
|
|
collectibleProviders,
|
|
mediaServer,
|
|
feed,
|
|
)
|
|
collectibles := collectibles.NewService(db, feed, accountsDB, accountFeed, settingsFeed, communityManager, rpcClient.NetworkManager, collectiblesManager)
|
|
|
|
activity := activity.NewService(db, accountsDB, tokenManager, collectiblesManager, feed, pendingTxManager)
|
|
|
|
router := router.NewRouter(rpcClient, transactor, tokenManager, marketManager, collectibles,
|
|
collectiblesManager)
|
|
pathProcessors := buildPathProcessors(rpcClient, transactor, tokenManager, ensResolver, featureFlags)
|
|
for _, processor := range pathProcessors {
|
|
router.AddPathProcessor(processor)
|
|
}
|
|
|
|
routeExecutionManager := routeexecution.NewManager(db, feed, router, transactionManager, transferController)
|
|
|
|
return &Service{
|
|
db: db,
|
|
accountsDB: accountsDB,
|
|
rpcClient: rpcClient,
|
|
tokenManager: tokenManager,
|
|
communityManager: communityManager,
|
|
savedAddressesManager: savedAddressesManager,
|
|
transactionManager: transactionManager,
|
|
pendingTxManager: pendingTxManager,
|
|
transferController: transferController,
|
|
cryptoOnRampManager: cryptoOnRampManager,
|
|
collectiblesManager: collectiblesManager,
|
|
collectibles: collectibles,
|
|
gethManager: gethManager,
|
|
marketManager: marketManager,
|
|
transactor: transactor,
|
|
feed: feed,
|
|
signals: signals,
|
|
reader: reader,
|
|
history: history,
|
|
currency: currency,
|
|
activity: activity,
|
|
decoder: NewDecoder(),
|
|
blockChainState: blockChainState,
|
|
keycardPairings: NewKeycardPairings(),
|
|
config: config,
|
|
featureFlags: featureFlags,
|
|
router: router,
|
|
routeExecutionManager: routeExecutionManager,
|
|
}
|
|
}
|
|
|
|
func buildPathProcessors(
|
|
rpcClient *rpc.Client,
|
|
transactor *transactions.Transactor,
|
|
tokenManager *token.Manager,
|
|
ensResolver *ensresolver.EnsResolver,
|
|
featureFlags *protocolCommon.FeatureFlags,
|
|
) []pathprocessor.PathProcessor {
|
|
ret := make([]pathprocessor.PathProcessor, 0)
|
|
|
|
transfer := pathprocessor.NewTransferProcessor(rpcClient, transactor)
|
|
ret = append(ret, transfer)
|
|
|
|
erc721Transfer := pathprocessor.NewERC721Processor(rpcClient, transactor)
|
|
ret = append(ret, erc721Transfer)
|
|
|
|
erc1155Transfer := pathprocessor.NewERC1155Processor(rpcClient, transactor)
|
|
ret = append(ret, erc1155Transfer)
|
|
|
|
hop := pathprocessor.NewHopBridgeProcessor(rpcClient, transactor, tokenManager, rpcClient.NetworkManager)
|
|
ret = append(ret, hop)
|
|
|
|
if featureFlags.EnableCelerBridge {
|
|
// TODO: Celar Bridge is out of scope for 2.30, check it thoroughly once we decide to include it again
|
|
cbridge := pathprocessor.NewCelerBridgeProcessor(rpcClient, transactor, tokenManager)
|
|
ret = append(ret, cbridge)
|
|
}
|
|
|
|
paraswap := pathprocessor.NewSwapParaswapProcessor(rpcClient, transactor, tokenManager)
|
|
ret = append(ret, paraswap)
|
|
|
|
ensRegister := pathprocessor.NewENSRegisterProcessor(rpcClient, transactor, ensResolver)
|
|
ret = append(ret, ensRegister)
|
|
|
|
ensRelease := pathprocessor.NewENSReleaseProcessor(rpcClient, transactor, ensResolver)
|
|
ret = append(ret, ensRelease)
|
|
|
|
ensPublicKey := pathprocessor.NewENSPublicKeyProcessor(rpcClient, transactor, ensResolver)
|
|
ret = append(ret, ensPublicKey)
|
|
|
|
buyStickers := pathprocessor.NewStickersBuyProcessor(rpcClient, transactor)
|
|
ret = append(ret, buyStickers)
|
|
|
|
return ret
|
|
}
|
|
|
|
// Service is a wallet service.
|
|
type Service struct {
|
|
db *sql.DB
|
|
accountsDB *accounts.Database
|
|
rpcClient *rpc.Client
|
|
savedAddressesManager *SavedAddressesManager
|
|
tokenManager *token.Manager
|
|
communityManager *community.Manager
|
|
transactionManager *transfer.TransactionManager
|
|
pendingTxManager *transactions.PendingTxTracker
|
|
cryptoOnRampManager *onramp.Manager
|
|
transferController *transfer.Controller
|
|
marketManager *market.Manager
|
|
started bool
|
|
collectiblesManager *collectibles.Manager
|
|
collectibles *collectibles.Service
|
|
gethManager *account.GethManager
|
|
transactor *transactions.Transactor
|
|
feed *event.Feed
|
|
signals *walletevent.SignalsTransmitter
|
|
reader *Reader
|
|
history *history.Service
|
|
currency *currency.Service
|
|
activity *activity.Service
|
|
decoder *Decoder
|
|
blockChainState *blockchainstate.BlockChainState
|
|
keycardPairings *KeycardPairings
|
|
config *params.NodeConfig
|
|
featureFlags *protocolCommon.FeatureFlags
|
|
router *router.Router
|
|
routeExecutionManager *routeexecution.Manager
|
|
}
|
|
|
|
// Start signals transmitter.
|
|
func (s *Service) Start() error {
|
|
s.transferController.Start()
|
|
s.currency.Start()
|
|
err := s.signals.Start()
|
|
s.history.Start()
|
|
s.collectibles.Start()
|
|
s.started = true
|
|
return err
|
|
}
|
|
|
|
// Set external Collectibles community info provider
|
|
func (s *Service) SetWalletCommunityInfoProvider(provider thirdparty.CommunityInfoProvider) {
|
|
s.communityManager.SetCommunityInfoProvider(provider)
|
|
}
|
|
|
|
// Stop reactor and close db.
|
|
func (s *Service) Stop() error {
|
|
logutils.ZapLogger().Info("wallet will be stopped")
|
|
s.router.Stop()
|
|
s.signals.Stop()
|
|
s.transferController.Stop()
|
|
s.currency.Stop()
|
|
s.reader.Stop()
|
|
s.history.Stop()
|
|
s.activity.Stop()
|
|
s.collectibles.Stop()
|
|
s.tokenManager.Stop()
|
|
s.started = false
|
|
logutils.ZapLogger().Info("wallet stopped")
|
|
return nil
|
|
}
|
|
|
|
// APIs returns list of available RPC APIs.
|
|
func (s *Service) APIs() []gethrpc.API {
|
|
return []gethrpc.API{
|
|
{
|
|
Namespace: "wallet",
|
|
Version: "0.1.0",
|
|
Service: NewAPI(s),
|
|
Public: true,
|
|
},
|
|
}
|
|
}
|
|
|
|
// Protocols returns list of p2p protocols.
|
|
func (s *Service) Protocols() []p2p.Protocol {
|
|
return nil
|
|
}
|
|
|
|
func (s *Service) IsStarted() bool {
|
|
return s.started
|
|
}
|
|
|
|
func (s *Service) KeycardPairings() *KeycardPairings {
|
|
return s.keycardPairings
|
|
}
|
|
|
|
func (s *Service) Config() *params.NodeConfig {
|
|
return s.config
|
|
}
|
|
|
|
func (s *Service) FeatureFlags() *protocolCommon.FeatureFlags {
|
|
return s.featureFlags
|
|
}
|
|
|
|
func (s *Service) GetRPCClient() *rpc.Client {
|
|
return s.rpcClient
|
|
}
|
|
|
|
func (s *Service) GetTransactor() *transactions.Transactor {
|
|
return s.transactor
|
|
}
|
|
|
|
func (s *Service) GetTokenManager() *token.Manager {
|
|
return s.tokenManager
|
|
}
|
|
|
|
func (s *Service) GetMarketManager() *market.Manager {
|
|
return s.marketManager
|
|
}
|
|
|
|
func (s *Service) GetCollectiblesService() *collectibles.Service {
|
|
return s.collectibles
|
|
}
|
|
|
|
func (s *Service) GetCollectiblesManager() *collectibles.Manager {
|
|
return s.collectiblesManager
|
|
}
|