430 lines
12 KiB
Go
430 lines
12 KiB
Go
package token
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"math/big"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/golang/mock/gomock"
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/event"
|
|
gethrpc "github.com/ethereum/go-ethereum/rpc"
|
|
|
|
"github.com/status-im/status-go/appdatabase"
|
|
"github.com/status-im/status-go/multiaccounts/accounts"
|
|
"github.com/status-im/status-go/params"
|
|
"github.com/status-im/status-go/rpc"
|
|
"github.com/status-im/status-go/rpc/network"
|
|
mediaserver "github.com/status-im/status-go/server"
|
|
"github.com/status-im/status-go/services/accounts/accountsevent"
|
|
"github.com/status-im/status-go/services/wallet/bigint"
|
|
"github.com/status-im/status-go/services/wallet/community"
|
|
|
|
"github.com/status-im/status-go/t/helpers"
|
|
"github.com/status-im/status-go/t/utils"
|
|
"github.com/status-im/status-go/transactions/fake"
|
|
"github.com/status-im/status-go/walletdatabase"
|
|
)
|
|
|
|
func setupTestTokenDB(t *testing.T) (*Manager, func()) {
|
|
db, err := helpers.SetupTestMemorySQLDB(walletdatabase.DbInitializer{})
|
|
require.NoError(t, err)
|
|
|
|
return &Manager{
|
|
db: db,
|
|
RPCClient: nil,
|
|
ContractMaker: nil,
|
|
networkManager: nil,
|
|
stores: nil,
|
|
communityTokensDB: nil,
|
|
communityManager: nil,
|
|
tokenBalancesStorage: NewPersistence(db),
|
|
}, func() {
|
|
require.NoError(t, db.Close())
|
|
}
|
|
}
|
|
|
|
func upsertCommunityToken(t *testing.T, token *Token, manager *Manager) {
|
|
require.NotNil(t, token.CommunityData)
|
|
|
|
err := manager.UpsertCustom(*token)
|
|
require.NoError(t, err)
|
|
|
|
// Community ID is only discovered by calling contract, so must be updated manually
|
|
_, err = manager.db.Exec("UPDATE tokens SET community_id = ? WHERE address = ?", token.CommunityData.ID, token.Address)
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestCustoms(t *testing.T) {
|
|
manager, stop := setupTestTokenDB(t)
|
|
defer stop()
|
|
|
|
rst, err := manager.GetCustoms(false)
|
|
require.NoError(t, err)
|
|
require.Nil(t, rst)
|
|
|
|
token := Token{
|
|
Address: common.Address{1},
|
|
Name: "Zilliqa",
|
|
Symbol: "ZIL",
|
|
Decimals: 12,
|
|
ChainID: 777,
|
|
}
|
|
|
|
err = manager.UpsertCustom(token)
|
|
require.NoError(t, err)
|
|
|
|
rst, err = manager.GetCustoms(false)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(rst))
|
|
require.Equal(t, token, *rst[0])
|
|
|
|
err = manager.DeleteCustom(777, token.Address)
|
|
require.NoError(t, err)
|
|
|
|
rst, err = manager.GetCustoms(false)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 0, len(rst))
|
|
}
|
|
|
|
func TestCommunityTokens(t *testing.T) {
|
|
manager, stop := setupTestTokenDB(t)
|
|
defer stop()
|
|
|
|
rst, err := manager.GetCustoms(true)
|
|
require.NoError(t, err)
|
|
require.Nil(t, rst)
|
|
|
|
token := Token{
|
|
Address: common.Address{1},
|
|
Name: "Zilliqa",
|
|
Symbol: "ZIL",
|
|
Decimals: 12,
|
|
ChainID: 777,
|
|
}
|
|
|
|
err = manager.UpsertCustom(token)
|
|
require.NoError(t, err)
|
|
|
|
communityToken := Token{
|
|
Address: common.Address{2},
|
|
Name: "Communitia",
|
|
Symbol: "COM",
|
|
Decimals: 12,
|
|
ChainID: 777,
|
|
CommunityData: &community.Data{
|
|
ID: "random_community_id",
|
|
},
|
|
}
|
|
|
|
upsertCommunityToken(t, &communityToken, manager)
|
|
|
|
rst, err = manager.GetCustoms(false)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, len(rst))
|
|
require.Equal(t, token, *rst[0])
|
|
require.Equal(t, communityToken, *rst[1])
|
|
|
|
rst, err = manager.GetCustoms(true)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(rst))
|
|
require.Equal(t, communityToken, *rst[0])
|
|
}
|
|
|
|
func toTokenMap(tokens []*Token) storeMap {
|
|
tokenMap := storeMap{}
|
|
|
|
for _, token := range tokens {
|
|
addTokMap := tokenMap[token.ChainID]
|
|
if addTokMap == nil {
|
|
addTokMap = make(addressTokenMap)
|
|
}
|
|
|
|
addTokMap[token.Address] = token
|
|
tokenMap[token.ChainID] = addTokMap
|
|
}
|
|
|
|
return tokenMap
|
|
}
|
|
|
|
func TestTokenOverride(t *testing.T) {
|
|
networks := []params.Network{
|
|
{
|
|
ChainID: 1,
|
|
ChainName: "TestChain1",
|
|
TokenOverrides: []params.TokenOverride{
|
|
{
|
|
Symbol: "SNT",
|
|
Address: common.Address{11},
|
|
},
|
|
},
|
|
}, {
|
|
ChainID: 2,
|
|
ChainName: "TestChain2",
|
|
TokenOverrides: []params.TokenOverride{
|
|
{
|
|
Symbol: "STT",
|
|
Address: common.Address{33},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
tokenList := []*Token{
|
|
&Token{
|
|
Address: common.Address{1},
|
|
Symbol: "SNT",
|
|
ChainID: 1,
|
|
},
|
|
&Token{
|
|
Address: common.Address{2},
|
|
Symbol: "TNT",
|
|
ChainID: 1,
|
|
},
|
|
&Token{
|
|
Address: common.Address{3},
|
|
Symbol: "STT",
|
|
ChainID: 2,
|
|
},
|
|
&Token{
|
|
Address: common.Address{4},
|
|
Symbol: "TTT",
|
|
ChainID: 2,
|
|
},
|
|
}
|
|
testStore := &DefaultStore{
|
|
tokenList,
|
|
}
|
|
|
|
overrideTokensInPlace(networks, tokenList)
|
|
tokens := testStore.GetTokens()
|
|
tokenMap := toTokenMap(tokens)
|
|
_, found := tokenMap[1][common.Address{1}]
|
|
require.False(t, found)
|
|
require.Equal(t, common.Address{11}, tokenMap[1][common.Address{11}].Address)
|
|
require.Equal(t, common.Address{2}, tokenMap[1][common.Address{2}].Address)
|
|
_, found = tokenMap[2][common.Address{3}]
|
|
require.False(t, found)
|
|
require.Equal(t, common.Address{33}, tokenMap[2][common.Address{33}].Address)
|
|
require.Equal(t, common.Address{4}, tokenMap[2][common.Address{4}].Address)
|
|
}
|
|
|
|
func TestMarkAsPreviouslyOwnedToken(t *testing.T) {
|
|
manager, stop := setupTestTokenDB(t)
|
|
defer stop()
|
|
|
|
owner := common.HexToAddress("0x1234567890abcdef")
|
|
token := &Token{
|
|
Address: common.HexToAddress("0xabcdef1234567890"),
|
|
Name: "TestToken",
|
|
Symbol: "TT",
|
|
Decimals: 18,
|
|
ChainID: 1,
|
|
}
|
|
|
|
isFirst, err := manager.MarkAsPreviouslyOwnedToken(nil, owner)
|
|
require.Error(t, err)
|
|
require.False(t, isFirst)
|
|
|
|
isFirst, err = manager.MarkAsPreviouslyOwnedToken(token, common.Address{})
|
|
require.Error(t, err)
|
|
require.False(t, isFirst)
|
|
|
|
isFirst, err = manager.MarkAsPreviouslyOwnedToken(token, owner)
|
|
require.NoError(t, err)
|
|
require.True(t, isFirst)
|
|
|
|
// Verify that the token balance was inserted correctly
|
|
var count int
|
|
err = manager.db.QueryRow(`SELECT count(*) FROM token_balances`).Scan(&count)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, count)
|
|
|
|
token.Name = "123"
|
|
|
|
isFirst, err = manager.MarkAsPreviouslyOwnedToken(token, owner)
|
|
require.NoError(t, err)
|
|
require.False(t, isFirst)
|
|
|
|
// Not updated because already exists
|
|
err = manager.db.QueryRow(`SELECT count(*) FROM token_balances`).Scan(&count)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, count)
|
|
|
|
token.ChainID = 2
|
|
|
|
isFirst, err = manager.MarkAsPreviouslyOwnedToken(token, owner)
|
|
require.NoError(t, err)
|
|
|
|
// Same token on different chains counts as different token
|
|
err = manager.db.QueryRow(`SELECT count(*) FROM token_balances`).Scan(&count)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, count)
|
|
require.True(t, isFirst)
|
|
}
|
|
|
|
func TestGetTokenHistoricalBalance(t *testing.T) {
|
|
manager, stop := setupTestTokenDB(t)
|
|
defer stop()
|
|
|
|
account := common.HexToAddress("0x1234567890abcdef")
|
|
chainID := uint64(1)
|
|
testSymbol := "TEST"
|
|
block := int64(1)
|
|
timestamp := int64(1629878400) // Replace with desired timestamp
|
|
historyBalance := big.NewInt(0)
|
|
|
|
// Test case when no rows are returned
|
|
balance, err := manager.GetTokenHistoricalBalance(account, chainID, testSymbol, timestamp)
|
|
require.NoError(t, err)
|
|
require.Nil(t, balance)
|
|
|
|
// Test case when a row is returned
|
|
historyBalance.SetInt64(int64(100))
|
|
_, err = manager.db.Exec("INSERT INTO balance_history (currency, chain_id, address, timestamp, balance, block) VALUES (?, ?, ?, ?, ?, ?)", testSymbol, chainID, account, timestamp-100, (*bigint.SQLBigIntBytes)(historyBalance), block)
|
|
require.NoError(t, err)
|
|
|
|
expectedBalance := big.NewInt(100)
|
|
balance, err = manager.GetTokenHistoricalBalance(account, chainID, testSymbol, timestamp)
|
|
require.NoError(t, err)
|
|
require.Equal(t, expectedBalance, balance)
|
|
|
|
// Test multiple values. Must return the most recent one
|
|
historyBalance.SetInt64(int64(100))
|
|
_, err = manager.db.Exec("INSERT INTO balance_history (currency, chain_id, address, timestamp, balance, block) VALUES (?, ?, ?, ?, ?, ?)", testSymbol, chainID, account, timestamp-200, (*bigint.SQLBigIntBytes)(historyBalance), block+1)
|
|
require.NoError(t, err)
|
|
|
|
historyBalance.SetInt64(int64(50))
|
|
symbol := "TEST2"
|
|
_, err = manager.db.Exec("INSERT INTO balance_history (currency, chain_id, address, timestamp, balance, block) VALUES (?, ?, ?, ?, ?, ?)", symbol, chainID, account, timestamp-1, (*bigint.SQLBigIntBytes)(historyBalance), block)
|
|
require.NoError(t, err)
|
|
|
|
historyBalance.SetInt64(int64(50))
|
|
chainID = uint64(2)
|
|
_, err = manager.db.Exec("INSERT INTO balance_history (currency, chain_id, address, timestamp, balance, block) VALUES (?, ?, ?, ?, ?, ?)", testSymbol, chainID, account, timestamp-1, (*bigint.SQLBigIntBytes)(historyBalance), block+2)
|
|
require.NoError(t, err)
|
|
|
|
chainID = uint64(1)
|
|
balance, err = manager.GetTokenHistoricalBalance(account, chainID, testSymbol, timestamp)
|
|
require.NoError(t, err)
|
|
require.Equal(t, expectedBalance, balance)
|
|
}
|
|
|
|
func Test_removeTokenBalanceOnEventAccountRemoved(t *testing.T) {
|
|
appDB, err := helpers.SetupTestMemorySQLDB(appdatabase.DbInitializer{})
|
|
require.NoError(t, err)
|
|
|
|
walletDB, err := helpers.SetupTestMemorySQLDB(walletdatabase.DbInitializer{})
|
|
require.NoError(t, err)
|
|
|
|
accountsDB, err := accounts.NewDB(appDB)
|
|
require.NoError(t, err)
|
|
|
|
address := common.HexToAddress("0x1234")
|
|
accountFeed := event.Feed{}
|
|
chainID := uint64(1)
|
|
txServiceMockCtrl := gomock.NewController(t)
|
|
server, _ := fake.NewTestServer(txServiceMockCtrl)
|
|
client := gethrpc.DialInProc(server)
|
|
rpcClient, _ := rpc.NewClient(client, chainID, params.UpstreamRPCConfig{}, nil, appDB)
|
|
rpcClient.UpstreamChainID = chainID
|
|
nm := network.NewManager(appDB)
|
|
mediaServer, err := mediaserver.NewMediaServer(appDB, nil, nil, walletDB)
|
|
require.NoError(t, err)
|
|
|
|
manager := NewTokenManager(walletDB, rpcClient, nil, nm, appDB, mediaServer, nil, &accountFeed, accountsDB, NewPersistence(walletDB))
|
|
|
|
// Insert balances for address
|
|
marked, err := manager.MarkAsPreviouslyOwnedToken(&Token{
|
|
Address: common.HexToAddress("0x1234"),
|
|
Symbol: "Dummy",
|
|
Decimals: 18,
|
|
ChainID: 1,
|
|
}, address)
|
|
require.NoError(t, err)
|
|
require.True(t, marked)
|
|
|
|
tokenByAddress, err := manager.GetPreviouslyOwnedTokens()
|
|
require.NoError(t, err)
|
|
require.Len(t, tokenByAddress, 1)
|
|
|
|
// Start service
|
|
manager.startAccountsWatcher()
|
|
|
|
// Watching accounts must start before sending event.
|
|
// To avoid running goroutine immediately and let the controller subscribe first,
|
|
// use any delay.
|
|
group := sync.WaitGroup{}
|
|
group.Add(1)
|
|
go func() {
|
|
defer group.Done()
|
|
time.Sleep(1 * time.Millisecond)
|
|
|
|
accountFeed.Send(accountsevent.Event{
|
|
Type: accountsevent.EventTypeRemoved,
|
|
Accounts: []common.Address{address},
|
|
})
|
|
|
|
require.NoError(t, utils.Eventually(func() error {
|
|
tokenByAddress, err := manager.GetPreviouslyOwnedTokens()
|
|
if err == nil && len(tokenByAddress) == 0 {
|
|
return nil
|
|
}
|
|
return errors.New("Token not removed")
|
|
}, 100*time.Millisecond, 10*time.Millisecond))
|
|
}()
|
|
|
|
group.Wait()
|
|
|
|
// Stop service
|
|
txServiceMockCtrl.Finish()
|
|
server.Stop()
|
|
manager.stopAccountsWatcher()
|
|
}
|
|
|
|
func Test_tokensListsValidity(t *testing.T) {
|
|
appDB, err := helpers.SetupTestMemorySQLDB(appdatabase.DbInitializer{})
|
|
require.NoError(t, err)
|
|
|
|
walletDB, err := helpers.SetupTestMemorySQLDB(walletdatabase.DbInitializer{})
|
|
require.NoError(t, err)
|
|
|
|
accountsDB, err := accounts.NewDB(appDB)
|
|
require.NoError(t, err)
|
|
|
|
nm := network.NewManager(appDB)
|
|
|
|
manager := NewTokenManager(walletDB, nil, nil, nm, appDB, nil, nil, nil, accountsDB, NewPersistence(walletDB))
|
|
require.NotNil(t, manager)
|
|
|
|
tokensListWrapper := manager.GetList()
|
|
require.NotNil(t, tokensListWrapper)
|
|
allLists := tokensListWrapper.Data
|
|
require.Greater(t, len(allLists), 0)
|
|
|
|
tmpMap := make(map[string][]*Token)
|
|
for _, list := range allLists {
|
|
for _, token := range list.Tokens {
|
|
key := fmt.Sprintf("%d-%s", token.ChainID, token.Symbol)
|
|
if added, ok := tmpMap[key]; ok {
|
|
found := false
|
|
for _, a := range added {
|
|
if a.Address == token.Address {
|
|
found = true
|
|
break
|
|
}
|
|
}
|
|
|
|
require.True(t, found)
|
|
} else {
|
|
tmpMap[key] = []*Token{token}
|
|
}
|
|
}
|
|
}
|
|
}
|