package transfer import ( "context" "fmt" "math/big" "sort" "strings" "sync" "testing" "time" "github.com/stretchr/testify/mock" "golang.org/x/exp/slices" // since 1.21, this is in the standard library "github.com/stretchr/testify/require" "github.com/ethereum/go-ethereum" "github.com/ethereum/go-ethereum/accounts/abi" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" "github.com/ethereum/go-ethereum/core/types" "github.com/ethereum/go-ethereum/event" "github.com/ethereum/go-ethereum/rpc" "github.com/status-im/status-go/appdatabase" "github.com/status-im/status-go/contracts/ethscan" "github.com/status-im/status-go/contracts/ierc20" "github.com/status-im/status-go/rpc/chain" "github.com/status-im/status-go/services/wallet/async" "github.com/status-im/status-go/services/wallet/balance" "github.com/status-im/status-go/t/helpers" "github.com/status-im/status-go/params" statusRpc "github.com/status-im/status-go/rpc" "github.com/status-im/status-go/rpc/network" walletcommon "github.com/status-im/status-go/services/wallet/common" "github.com/status-im/status-go/services/wallet/token" "github.com/status-im/status-go/transactions" "github.com/status-im/status-go/walletdatabase" ) type TestClient struct { t *testing.T // [][block, newBalance, nonceDiff] balances [][]int outgoingERC20Transfers []testERC20Transfer incomingERC20Transfers []testERC20Transfer outgoingERC1155SingleTransfers []testERC20Transfer incomingERC1155SingleTransfers []testERC20Transfer balanceHistory map[uint64]*big.Int tokenBalanceHistory map[common.Address]map[uint64]*big.Int nonceHistory map[uint64]uint64 traceAPICalls bool printPreparedData bool rw sync.RWMutex callsCounter map[string]int currentBlock uint64 } func (tc *TestClient) incCounter(method string) { tc.rw.Lock() defer tc.rw.Unlock() tc.callsCounter[method] = tc.callsCounter[method] + 1 } func (tc *TestClient) getCounter() int { tc.rw.RLock() defer tc.rw.RUnlock() cnt := 0 for _, v := range tc.callsCounter { cnt += v } return cnt } func (tc *TestClient) printCounter() { total := tc.getCounter() tc.rw.RLock() defer tc.rw.RUnlock() tc.t.Log("========================================= Total calls", total) for k, v := range tc.callsCounter { tc.t.Log(k, v) } tc.t.Log("=========================================") } func (tc *TestClient) BatchCallContext(ctx context.Context, b []rpc.BatchElem) error { if tc.traceAPICalls { tc.t.Log("BatchCallContext") } return nil } func (tc *TestClient) HeaderByHash(ctx context.Context, hash common.Hash) (*types.Header, error) { tc.incCounter("HeaderByHash") if tc.traceAPICalls { tc.t.Log("HeaderByHash") } return nil, nil } func (tc *TestClient) BlockByHash(ctx context.Context, hash common.Hash) (*types.Block, error) { tc.incCounter("BlockByHash") if tc.traceAPICalls { tc.t.Log("BlockByHash") } return nil, nil } func (tc *TestClient) BlockByNumber(ctx context.Context, number *big.Int) (*types.Block, error) { tc.incCounter("BlockByNumber") if tc.traceAPICalls { tc.t.Log("BlockByNumber") } return nil, nil } func (tc *TestClient) NonceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (uint64, error) { tc.incCounter("NonceAt") nonce := tc.nonceHistory[blockNumber.Uint64()] if tc.traceAPICalls { tc.t.Log("NonceAt", blockNumber, "result:", nonce) } return nonce, nil } func (tc *TestClient) FilterLogs(ctx context.Context, q ethereum.FilterQuery) ([]types.Log, error) { tc.incCounter("FilterLogs") if tc.traceAPICalls { tc.t.Log("FilterLogs") } // We do not verify addresses for now allTransfers := []testERC20Transfer{} signatures := q.Topics[0] erc20TransferSignature := walletcommon.GetEventSignatureHash(walletcommon.Erc20_721TransferEventSignature) erc1155TransferSingleSignature := walletcommon.GetEventSignatureHash(walletcommon.Erc1155TransferSingleEventSignature) var address common.Hash for i := 1; i < len(q.Topics); i++ { if len(q.Topics[i]) > 0 { address = q.Topics[i][0] break } } if slices.Contains(signatures, erc1155TransferSingleSignature) { from := q.Topics[2] var to []common.Hash if len(q.Topics) > 3 { to = q.Topics[3] } if len(to) > 0 { allTransfers = append(allTransfers, tc.incomingERC1155SingleTransfers...) } if len(from) > 0 { allTransfers = append(allTransfers, tc.outgoingERC1155SingleTransfers...) } } if slices.Contains(signatures, erc20TransferSignature) { from := q.Topics[1] to := q.Topics[2] if len(to) > 0 { allTransfers = append(allTransfers, tc.incomingERC20Transfers...) } if len(from) > 0 { allTransfers = append(allTransfers, tc.outgoingERC20Transfers...) } } logs := []types.Log{} for _, transfer := range allTransfers { if transfer.block.Cmp(q.FromBlock) >= 0 && transfer.block.Cmp(q.ToBlock) <= 0 { log := types.Log{ BlockNumber: transfer.block.Uint64(), BlockHash: common.BigToHash(transfer.block), } // Use the address at least in one any(from/to) topic to trick the implementation switch transfer.eventType { case walletcommon.Erc20TransferEventType, walletcommon.Erc721TransferEventType: // To detect properly ERC721, we need a different number of topics. For now we use only ERC20 for testing log.Topics = []common.Hash{walletcommon.GetEventSignatureHash(walletcommon.Erc20_721TransferEventSignature), address, address} case walletcommon.Erc1155TransferSingleEventType: log.Topics = []common.Hash{walletcommon.GetEventSignatureHash(walletcommon.Erc1155TransferSingleEventSignature), address, address, address} log.Data = make([]byte, 2*common.HashLength) case walletcommon.Erc1155TransferBatchEventType: log.Topics = []common.Hash{walletcommon.GetEventSignatureHash(walletcommon.Erc1155TransferBatchEventSignature), address, address, address} } logs = append(logs, log) } } return logs, nil } func (tc *TestClient) BalanceAt(ctx context.Context, account common.Address, blockNumber *big.Int) (*big.Int, error) { tc.incCounter("BalanceAt") balance := tc.balanceHistory[blockNumber.Uint64()] if tc.traceAPICalls { tc.t.Log("BalanceAt", blockNumber, "result:", balance) } return balance, nil } func (tc *TestClient) tokenBalanceAt(token common.Address, blockNumber *big.Int) *big.Int { balance := tc.tokenBalanceHistory[token][blockNumber.Uint64()] if balance == nil { balance = big.NewInt(0) } if tc.traceAPICalls { tc.t.Log("tokenBalanceAt", token, blockNumber, "result:", balance) } return balance } func (tc *TestClient) HeaderByNumber(ctx context.Context, number *big.Int) (*types.Header, error) { tc.incCounter("HeaderByNumber") if number == nil { number = big.NewInt(int64(tc.currentBlock)) } if tc.traceAPICalls { tc.t.Log("HeaderByNumber", number) } header := &types.Header{ Number: number, Time: 0, } return header, nil } func (tc *TestClient) FullTransactionByBlockNumberAndIndex(ctx context.Context, blockNumber *big.Int, index uint) (*chain.FullTransaction, error) { tc.incCounter("FullTransactionByBlockNumberAndIndex") if tc.traceAPICalls { tc.t.Log("FullTransactionByBlockNumberAndIndex") } blockHash := common.BigToHash(blockNumber) tx := &chain.FullTransaction{ Tx: &types.Transaction{}, TxExtraInfo: chain.TxExtraInfo{ BlockNumber: (*hexutil.Big)(big.NewInt(0)), BlockHash: &blockHash, }, } return tx, nil } func (tc *TestClient) GetBaseFeeFromBlock(blockNumber *big.Int) (string, error) { tc.incCounter("GetBaseFeeFromBlock") if tc.traceAPICalls { tc.t.Log("GetBaseFeeFromBlock") } return "", nil } func (tc *TestClient) NetworkID() uint64 { return 777333 } func (tc *TestClient) ToBigInt() *big.Int { if tc.traceAPICalls { tc.t.Log("ToBigInt") } return nil } var ethscanAddress = common.HexToAddress("0x0000000000000000000000000000000000777333") func (tc *TestClient) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) { tc.incCounter("CodeAt") if tc.traceAPICalls { tc.t.Log("CodeAt", contract, blockNumber) } if ethscanAddress == contract { return []byte{1}, nil } return nil, nil } func (tc *TestClient) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) { tc.incCounter("CallContract") if tc.traceAPICalls { tc.t.Log("CallContract", call, blockNumber, call.To) } if *call.To == ethscanAddress { parsed, err := abi.JSON(strings.NewReader(ethscan.BalanceScannerABI)) if err != nil { return nil, err } method := parsed.Methods["tokensBalance"] params := call.Data[len(method.ID):] args, err := method.Inputs.Unpack(params) if err != nil { tc.t.Log("ERROR on unpacking", err) return nil, err } tokens := args[1].([]common.Address) balances := []*big.Int{} for _, token := range tokens { balances = append(balances, tc.tokenBalanceAt(token, blockNumber)) } results := []ethscan.BalanceScannerResult{} for _, balance := range balances { results = append(results, ethscan.BalanceScannerResult{ Success: true, Data: balance.Bytes(), }) } output, err := method.Outputs.Pack(results) if err != nil { tc.t.Log("ERROR on packing", err) return nil, err } return output, nil } if *call.To == tokenTXXAddress || *call.To == tokenTXYAddress { balance := tc.tokenBalanceAt(*call.To, blockNumber) parsed, err := abi.JSON(strings.NewReader(ierc20.IERC20ABI)) if err != nil { return nil, err } method := parsed.Methods["balanceOf"] output, err := method.Outputs.Pack(balance) if err != nil { tc.t.Log("ERROR on packing ERC20 balance", err) return nil, err } return output, nil } return nil, nil } func (tc *TestClient) prepareBalanceHistory(toBlock int) { var currentBlock, currentBalance, currentNonce int tc.balanceHistory = map[uint64]*big.Int{} tc.nonceHistory = map[uint64]uint64{} if len(tc.balances) == 0 { tc.balances = append(tc.balances, []int{toBlock + 1, 0, 0}) } else { lastBlock := tc.balances[len(tc.balances)-1] tc.balances = append(tc.balances, []int{toBlock + 1, lastBlock[1], 0}) } for _, change := range tc.balances { for blockN := currentBlock; blockN < change[0]; blockN++ { tc.balanceHistory[uint64(blockN)] = big.NewInt(int64(currentBalance)) tc.nonceHistory[uint64(blockN)] = uint64(currentNonce) } currentBlock = change[0] currentBalance = change[1] currentNonce += change[2] } if tc.printPreparedData { tc.t.Log("========================================= ETH BALANCES") tc.t.Log(tc.balanceHistory) tc.t.Log(tc.nonceHistory) tc.t.Log(tc.tokenBalanceHistory) tc.t.Log("=========================================") } } func (tc *TestClient) prepareTokenBalanceHistory(toBlock int) { transfersPerToken := map[common.Address][]testERC20Transfer{} for _, transfer := range tc.outgoingERC20Transfers { transfer.amount = new(big.Int).Neg(transfer.amount) transfer.eventType = walletcommon.Erc20TransferEventType transfersPerToken[transfer.address] = append(transfersPerToken[transfer.address], transfer) } for _, transfer := range tc.incomingERC20Transfers { transfer.eventType = walletcommon.Erc20TransferEventType transfersPerToken[transfer.address] = append(transfersPerToken[transfer.address], transfer) } for _, transfer := range tc.outgoingERC1155SingleTransfers { transfer.amount = new(big.Int).Neg(transfer.amount) transfer.eventType = walletcommon.Erc1155TransferSingleEventType transfersPerToken[transfer.address] = append(transfersPerToken[transfer.address], transfer) } for _, transfer := range tc.incomingERC1155SingleTransfers { transfer.eventType = walletcommon.Erc1155TransferSingleEventType transfersPerToken[transfer.address] = append(transfersPerToken[transfer.address], transfer) } tc.tokenBalanceHistory = map[common.Address]map[uint64]*big.Int{} for token, transfers := range transfersPerToken { sort.Slice(transfers, func(i, j int) bool { return transfers[i].block.Cmp(transfers[j].block) < 0 }) currentBlock := uint64(0) currentBalance := big.NewInt(0) tc.tokenBalanceHistory[token] = map[uint64]*big.Int{} transfers = append(transfers, testERC20Transfer{big.NewInt(int64(toBlock + 1)), token, big.NewInt(0), walletcommon.Erc20TransferEventType}) for _, transfer := range transfers { for blockN := currentBlock; blockN < transfer.block.Uint64(); blockN++ { tc.tokenBalanceHistory[token][blockN] = new(big.Int).Set(currentBalance) } currentBlock = transfer.block.Uint64() currentBalance = new(big.Int).Add(currentBalance, transfer.amount) } } if tc.printPreparedData { tc.t.Log("========================================= ERC20 BALANCES") tc.t.Log(tc.tokenBalanceHistory) tc.t.Log("=========================================") } } func (tc *TestClient) CallContext(ctx context.Context, result interface{}, method string, args ...interface{}) error { tc.incCounter("CallContext") if tc.traceAPICalls { tc.t.Log("CallContext") } return nil } func (tc *TestClient) GetWalletNotifier() func(chainId uint64, message string) { if tc.traceAPICalls { tc.t.Log("GetWalletNotifier") } return nil } func (tc *TestClient) SetWalletNotifier(notifier func(chainId uint64, message string)) { if tc.traceAPICalls { tc.t.Log("SetWalletNotifier") } } func (tc *TestClient) EstimateGas(ctx context.Context, call ethereum.CallMsg) (gas uint64, err error) { tc.incCounter("EstimateGas") if tc.traceAPICalls { tc.t.Log("EstimateGas") } return 0, nil } func (tc *TestClient) PendingCodeAt(ctx context.Context, account common.Address) ([]byte, error) { tc.incCounter("PendingCodeAt") if tc.traceAPICalls { tc.t.Log("PendingCodeAt") } return nil, nil } func (tc *TestClient) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) { tc.incCounter("PendingCallContract") if tc.traceAPICalls { tc.t.Log("PendingCallContract") } return nil, nil } func (tc *TestClient) PendingNonceAt(ctx context.Context, account common.Address) (uint64, error) { tc.incCounter("PendingNonceAt") if tc.traceAPICalls { tc.t.Log("PendingNonceAt") } return 0, nil } func (tc *TestClient) SuggestGasPrice(ctx context.Context) (*big.Int, error) { tc.incCounter("SuggestGasPrice") if tc.traceAPICalls { tc.t.Log("SuggestGasPrice") } return nil, nil } func (tc *TestClient) SendTransaction(ctx context.Context, tx *types.Transaction) error { tc.incCounter("SendTransaction") if tc.traceAPICalls { tc.t.Log("SendTransaction") } return nil } func (tc *TestClient) SuggestGasTipCap(ctx context.Context) (*big.Int, error) { tc.incCounter("SuggestGasTipCap") if tc.traceAPICalls { tc.t.Log("SuggestGasTipCap") } return nil, nil } func (tc *TestClient) BatchCallContextIgnoringLocalHandlers(ctx context.Context, b []rpc.BatchElem) error { tc.incCounter("BatchCallContextIgnoringLocalHandlers") if tc.traceAPICalls { tc.t.Log("BatchCallContextIgnoringLocalHandlers") } return nil } func (tc *TestClient) CallContextIgnoringLocalHandlers(ctx context.Context, result interface{}, method string, args ...interface{}) error { tc.incCounter("CallContextIgnoringLocalHandlers") if tc.traceAPICalls { tc.t.Log("CallContextIgnoringLocalHandlers") } return nil } func (tc *TestClient) CallRaw(data string) string { tc.incCounter("CallRaw") if tc.traceAPICalls { tc.t.Log("CallRaw") } return "" } func (tc *TestClient) GetChainID() *big.Int { return big.NewInt(1) } func (tc *TestClient) SubscribeFilterLogs(ctx context.Context, q ethereum.FilterQuery, ch chan<- types.Log) (ethereum.Subscription, error) { tc.incCounter("SubscribeFilterLogs") if tc.traceAPICalls { tc.t.Log("SubscribeFilterLogs") } return nil, nil } func (tc *TestClient) TransactionReceipt(ctx context.Context, txHash common.Hash) (*types.Receipt, error) { tc.incCounter("TransactionReceipt") if tc.traceAPICalls { tc.t.Log("TransactionReceipt") } return nil, nil } func (tc *TestClient) TransactionByHash(ctx context.Context, txHash common.Hash) (*types.Transaction, bool, error) { tc.incCounter("TransactionByHash") if tc.traceAPICalls { tc.t.Log("TransactionByHash") } return nil, false, nil } func (tc *TestClient) BlockNumber(ctx context.Context) (uint64, error) { tc.incCounter("BlockNumber") if tc.traceAPICalls { tc.t.Log("BlockNumber") } return 0, nil } func (tc *TestClient) SetIsConnected(value bool) { if tc.traceAPICalls { tc.t.Log("SetIsConnected") } } func (tc *TestClient) GetIsConnected() bool { if tc.traceAPICalls { tc.t.Log("GetIsConnected") } return true } type testERC20Transfer struct { block *big.Int address common.Address amount *big.Int eventType walletcommon.EventType } type findBlockCase struct { balanceChanges [][]int ERC20BalanceChanges [][]int fromBlock int64 toBlock int64 rangeSize int expectedBlocksFound int outgoingERC20Transfers []testERC20Transfer incomingERC20Transfers []testERC20Transfer outgoingERC1155SingleTransfers []testERC20Transfer incomingERC1155SingleTransfers []testERC20Transfer label string expectedCalls map[string]int } func transferInEachBlock() [][]int { res := [][]int{} for i := 1; i < 101; i++ { res = append(res, []int{i, i, i}) } return res } func getCases() []findBlockCase { cases := []findBlockCase{} case1 := findBlockCase{ balanceChanges: [][]int{ {5, 1, 0}, {20, 2, 0}, {45, 1, 1}, {46, 50, 0}, {75, 0, 1}, }, outgoingERC20Transfers: []testERC20Transfer{ {big.NewInt(6), tokenTXXAddress, big.NewInt(1), walletcommon.Erc20TransferEventType}, }, toBlock: 100, expectedBlocksFound: 6, expectedCalls: map[string]int{ "FilterLogs": 15, "HeaderByNumber": 5, }, } case100transfers := findBlockCase{ balanceChanges: transferInEachBlock(), toBlock: 100, expectedBlocksFound: 100, expectedCalls: map[string]int{ "BalanceAt": 101, "NonceAt": 0, "FilterLogs": 15, "HeaderByNumber": 100, }, } case3 := findBlockCase{ balanceChanges: [][]int{ {1, 1, 1}, {2, 2, 2}, {45, 1, 1}, {46, 50, 0}, {75, 0, 1}, }, toBlock: 100, expectedBlocksFound: 5, } case4 := findBlockCase{ balanceChanges: [][]int{ {20, 1, 0}, }, toBlock: 100, fromBlock: 10, expectedBlocksFound: 1, label: "single block", } case5 := findBlockCase{ balanceChanges: [][]int{}, toBlock: 100, fromBlock: 20, expectedBlocksFound: 0, } case6 := findBlockCase{ balanceChanges: [][]int{ {20, 1, 0}, {45, 1, 1}, }, toBlock: 100, fromBlock: 30, expectedBlocksFound: 1, rangeSize: 20, label: "single block in range", } case7emptyHistoryWithOneERC20Transfer := findBlockCase{ balanceChanges: [][]int{}, toBlock: 100, rangeSize: 20, expectedBlocksFound: 1, incomingERC20Transfers: []testERC20Transfer{ {big.NewInt(6), tokenTXXAddress, big.NewInt(1), walletcommon.Erc20TransferEventType}, }, } case8emptyHistoryWithERC20Transfers := findBlockCase{ balanceChanges: [][]int{}, toBlock: 100, rangeSize: 20, expectedBlocksFound: 2, incomingERC20Transfers: []testERC20Transfer{ // edge case when a regular scan will find transfer at 80, // but erc20 tail scan should only find transfer at block 6 {big.NewInt(80), tokenTXXAddress, big.NewInt(1), walletcommon.Erc20TransferEventType}, {big.NewInt(6), tokenTXXAddress, big.NewInt(1), walletcommon.Erc20TransferEventType}, }, expectedCalls: map[string]int{ "FilterLogs": 5, "CallContract": 3, }, } case9emptyHistoryWithERC20Transfers := findBlockCase{ balanceChanges: [][]int{}, toBlock: 100, rangeSize: 20, // we expect only a single eth_getLogs to be executed here for both erc20 transfers, // thus only 2 blocks found expectedBlocksFound: 2, incomingERC20Transfers: []testERC20Transfer{ {big.NewInt(7), tokenTXYAddress, big.NewInt(1), walletcommon.Erc20TransferEventType}, {big.NewInt(6), tokenTXXAddress, big.NewInt(1), walletcommon.Erc20TransferEventType}, }, expectedCalls: map[string]int{ "FilterLogs": 5, }, } case10 := findBlockCase{ balanceChanges: [][]int{}, toBlock: 100, fromBlock: 99, expectedBlocksFound: 0, label: "single block range, no transactions", expectedCalls: map[string]int{ // only two requests to check the range for incoming ERC20 "FilterLogs": 3, // no contract calls as ERC20 is not checked "CallContract": 0, }, } case11IncomingERC1155SingleTransfers := findBlockCase{ balanceChanges: [][]int{}, toBlock: 100, rangeSize: 20, // we expect only a single eth_getLogs to be executed here for both erc20 transfers, // thus only 2 blocks found expectedBlocksFound: 2, incomingERC1155SingleTransfers: []testERC20Transfer{ {big.NewInt(7), tokenTXYAddress, big.NewInt(1), walletcommon.Erc1155TransferSingleEventType}, {big.NewInt(6), tokenTXXAddress, big.NewInt(1), walletcommon.Erc1155TransferSingleEventType}, }, expectedCalls: map[string]int{ "FilterLogs": 5, "CallContract": 5, }, } case12OutgoingERC1155SingleTransfers := findBlockCase{ balanceChanges: [][]int{ {6, 1, 0}, }, toBlock: 100, rangeSize: 20, expectedBlocksFound: 3, outgoingERC1155SingleTransfers: []testERC20Transfer{ {big.NewInt(80), tokenTXYAddress, big.NewInt(1), walletcommon.Erc1155TransferSingleEventType}, {big.NewInt(6), tokenTXXAddress, big.NewInt(1), walletcommon.Erc1155TransferSingleEventType}, }, expectedCalls: map[string]int{ "FilterLogs": 15, // 3 for each range }, } case13outgoingERC20ERC1155SingleTransfers := findBlockCase{ balanceChanges: [][]int{ {63, 1, 0}, }, toBlock: 100, rangeSize: 20, expectedBlocksFound: 3, outgoingERC1155SingleTransfers: []testERC20Transfer{ {big.NewInt(80), tokenTXYAddress, big.NewInt(1), walletcommon.Erc1155TransferSingleEventType}, }, outgoingERC20Transfers: []testERC20Transfer{ {big.NewInt(63), tokenTXYAddress, big.NewInt(1), walletcommon.Erc20TransferEventType}, }, expectedCalls: map[string]int{ "FilterLogs": 6, // 3 for each range, 0 for tail check becauseERC20ScanByBalance returns no ranges }, } case14outgoingERC20ERC1155SingleTransfersMoreFilterLogs := findBlockCase{ balanceChanges: [][]int{ {61, 1, 0}, }, toBlock: 100, rangeSize: 20, expectedBlocksFound: 3, outgoingERC1155SingleTransfers: []testERC20Transfer{ {big.NewInt(80), tokenTXYAddress, big.NewInt(1), walletcommon.Erc1155TransferSingleEventType}, }, outgoingERC20Transfers: []testERC20Transfer{ {big.NewInt(61), tokenTXYAddress, big.NewInt(1), walletcommon.Erc20TransferEventType}, }, expectedCalls: map[string]int{ "FilterLogs": 9, // 3 for each range of [40-100], 0 for tail check because ERC20ScanByBalance returns no ranges }, label: "outgoing ERC20 and ERC1155 transfers but more FilterLogs calls because startFromBlock is not detected at range [60-80] as it is in the first subrange", } case15incomingERC20outgoingERC1155SingleTransfers := findBlockCase{ balanceChanges: [][]int{ {85, 1, 0}, }, toBlock: 100, rangeSize: 20, expectedBlocksFound: 2, outgoingERC1155SingleTransfers: []testERC20Transfer{ {big.NewInt(85), tokenTXYAddress, big.NewInt(1), walletcommon.Erc1155TransferSingleEventType}, }, incomingERC20Transfers: []testERC20Transfer{ {big.NewInt(88), tokenTXYAddress, big.NewInt(1), walletcommon.Erc20TransferEventType}, }, expectedCalls: map[string]int{ "FilterLogs": 3, // 3 for each range of [40-100], 0 for tail check because ERC20ScanByBalance returns no ranges }, label: "incoming ERC20 and outgoing ERC1155 transfers are fetched with same topic", } case16 := findBlockCase{ balanceChanges: [][]int{ {75, 0, 1}, }, outgoingERC20Transfers: []testERC20Transfer{ {big.NewInt(80), tokenTXXAddress, big.NewInt(4), walletcommon.Erc20TransferEventType}, }, toBlock: 100, rangeSize: 20, expectedBlocksFound: 3, // ideally we should find 2 blocks, but we will find 3 and this test shows that we are ok with that label: `duplicate blocks detected but we wont fix it because we want to save requests on the edges of the ranges, taking balance and nonce from cache while ETH and tokens ranges searching are tightly coupled`, } cases = append(cases, case1) cases = append(cases, case100transfers) cases = append(cases, case3) cases = append(cases, case4) cases = append(cases, case5) cases = append(cases, case6) cases = append(cases, case7emptyHistoryWithOneERC20Transfer) cases = append(cases, case8emptyHistoryWithERC20Transfers) cases = append(cases, case9emptyHistoryWithERC20Transfers) cases = append(cases, case10) cases = append(cases, case11IncomingERC1155SingleTransfers) cases = append(cases, case12OutgoingERC1155SingleTransfers) cases = append(cases, case13outgoingERC20ERC1155SingleTransfers) cases = append(cases, case14outgoingERC20ERC1155SingleTransfersMoreFilterLogs) cases = append(cases, case15incomingERC20outgoingERC1155SingleTransfers) cases = append(cases, case16) //cases = append([]findBlockCase{}, case10) return cases } var tokenTXXAddress = common.HexToAddress("0x53211") var tokenTXYAddress = common.HexToAddress("0x73211") func TestFindBlocksCommand(t *testing.T) { for idx, testCase := range getCases() { t.Log("case #", idx+1) ctx := context.Background() group := async.NewGroup(ctx) appdb, err := helpers.SetupTestMemorySQLDB(appdatabase.DbInitializer{}) require.NoError(t, err) db, err := helpers.SetupTestMemorySQLDB(walletdatabase.DbInitializer{}) require.NoError(t, err) tm := &TransactionManager{db, nil, nil, nil, nil, nil, nil, nil, nil, nil} wdb := NewDB(db) tc := &TestClient{ t: t, balances: testCase.balanceChanges, outgoingERC20Transfers: testCase.outgoingERC20Transfers, incomingERC20Transfers: testCase.incomingERC20Transfers, outgoingERC1155SingleTransfers: testCase.outgoingERC1155SingleTransfers, incomingERC1155SingleTransfers: testCase.incomingERC1155SingleTransfers, callsCounter: map[string]int{}, } // tc.traceAPICalls = true // tc.printPreparedData = true tc.prepareBalanceHistory(100) tc.prepareTokenBalanceHistory(100) blockChannel := make(chan []*DBHeader, 100) rangeSize := 20 if testCase.rangeSize != 0 { rangeSize = testCase.rangeSize } client, _ := statusRpc.NewClient(nil, 1, params.UpstreamRPCConfig{Enabled: false, URL: ""}, []params.Network{}, db) client.SetClient(tc.NetworkID(), tc) tokenManager := token.NewTokenManager(db, client, network.NewManager(appdb)) tokenManager.SetTokens([]*token.Token{ { Address: tokenTXXAddress, Symbol: "TXX", Decimals: 18, ChainID: tc.NetworkID(), Name: "Test Token 1", Verified: true, }, { Address: tokenTXYAddress, Symbol: "TXY", Decimals: 18, ChainID: tc.NetworkID(), Name: "Test Token 2", Verified: true, }, }) fbc := &findBlocksCommand{ account: common.HexToAddress("0x1234"), db: wdb, blockRangeDAO: &BlockRangeSequentialDAO{wdb.client}, chainClient: tc, balanceCacher: balance.NewCacherWithTTL(5 * time.Minute), feed: &event.Feed{}, noLimit: false, fromBlockNumber: big.NewInt(testCase.fromBlock), toBlockNumber: big.NewInt(testCase.toBlock), transactionManager: tm, blocksLoadedCh: blockChannel, defaultNodeBlockChunkSize: rangeSize, tokenManager: tokenManager, } group.Add(fbc.Command()) foundBlocks := []*DBHeader{} select { case <-ctx.Done(): t.Log("ERROR") case <-group.WaitAsync(): close(blockChannel) for { bloks, ok := <-blockChannel if !ok { break } foundBlocks = append(foundBlocks, bloks...) } numbers := []int64{} for _, block := range foundBlocks { numbers = append(numbers, block.Number.Int64()) } if tc.traceAPICalls { tc.printCounter() } for name, cnt := range testCase.expectedCalls { require.Equal(t, cnt, tc.callsCounter[name], "calls to "+name) } sort.Slice(numbers, func(i, j int) bool { return numbers[i] < numbers[j] }) require.Equal(t, testCase.expectedBlocksFound, len(foundBlocks), testCase.label, "found blocks", numbers) } } } type MockETHClient struct { mock.Mock } func (m *MockETHClient) BatchCallContext(ctx context.Context, b []rpc.BatchElem) error { args := m.Called(ctx, b) return args.Error(0) } type MockChainClient struct { mock.Mock clients map[walletcommon.ChainID]*MockETHClient } func newMockChainClient() *MockChainClient { return &MockChainClient{ clients: make(map[walletcommon.ChainID]*MockETHClient), } } func (m *MockChainClient) AbstractEthClient(chainID walletcommon.ChainID) (chain.BatchCallClient, error) { if _, ok := m.clients[chainID]; !ok { panic(fmt.Sprintf("no mock client for chainID %d", chainID)) } return m.clients[chainID], nil } func TestFetchTransfersForLoadedBlocks(t *testing.T) { appdb, err := helpers.SetupTestMemorySQLDB(appdatabase.DbInitializer{}) require.NoError(t, err) db, err := helpers.SetupTestMemorySQLDB(walletdatabase.DbInitializer{}) require.NoError(t, err) tm := &TransactionManager{db, nil, nil, nil, nil, nil, nil, nil, nil, nil} wdb := NewDB(db) blockChannel := make(chan []*DBHeader, 100) tc := &TestClient{ t: t, balances: [][]int{}, outgoingERC20Transfers: []testERC20Transfer{}, incomingERC20Transfers: []testERC20Transfer{}, callsCounter: map[string]int{}, currentBlock: 100, } client, _ := statusRpc.NewClient(nil, 1, params.UpstreamRPCConfig{Enabled: false, URL: ""}, []params.Network{}, db) client.SetClient(tc.NetworkID(), tc) tokenManager := token.NewTokenManager(db, client, network.NewManager(appdb)) tokenManager.SetTokens([]*token.Token{ { Address: tokenTXXAddress, Symbol: "TXX", Decimals: 18, ChainID: tc.NetworkID(), Name: "Test Token 1", Verified: true, }, { Address: tokenTXYAddress, Symbol: "TXY", Decimals: 18, ChainID: tc.NetworkID(), Name: "Test Token 2", Verified: true, }, }) chainClient := newMockChainClient() tracker := transactions.NewPendingTxTracker(db, chainClient, nil, &event.Feed{}, transactions.PendingCheckInterval) cmd := &loadBlocksAndTransfersCommand{ account: common.HexToAddress("0x1234"), db: wdb, blockRangeDAO: &BlockRangeSequentialDAO{wdb.client}, blockDAO: &BlockDAO{db}, chainClient: tc, feed: &event.Feed{}, balanceCacher: balance.NewCacherWithTTL(5 * time.Minute), transactionManager: tm, pendingTxManager: tracker, tokenManager: tokenManager, blocksLoadedCh: blockChannel, omitHistory: true, } tc.prepareBalanceHistory(int(tc.currentBlock)) tc.prepareTokenBalanceHistory(int(tc.currentBlock)) tc.traceAPICalls = true ctx := context.Background() group := async.NewGroup(ctx) fromNum := big.NewInt(0) toNum, err := getHeadBlockNumber(ctx, cmd.chainClient) require.NoError(t, err) err = cmd.fetchHistoryBlocks(ctx, group, fromNum, toNum, blockChannel) require.NoError(t, err) select { case <-ctx.Done(): t.Log("ERROR") case <-group.WaitAsync(): require.Equal(t, 1, tc.getCounter()) } }