504 lines
14 KiB
Go
504 lines
14 KiB
Go
package transfer
|
|
|
|
import (
|
|
"database/sql"
|
|
"fmt"
|
|
"math/big"
|
|
"testing"
|
|
|
|
eth_common "github.com/ethereum/go-ethereum/common"
|
|
"github.com/ethereum/go-ethereum/common/hexutil"
|
|
"github.com/ethereum/go-ethereum/core/types"
|
|
|
|
"github.com/status-im/status-go/services/wallet/bigint"
|
|
"github.com/status-im/status-go/services/wallet/common"
|
|
"github.com/status-im/status-go/services/wallet/testutils"
|
|
"github.com/status-im/status-go/services/wallet/token"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
type TestTransaction struct {
|
|
Hash eth_common.Hash
|
|
ChainID common.ChainID
|
|
From eth_common.Address // [sender]
|
|
Timestamp int64
|
|
BlkNumber int64
|
|
Success bool
|
|
Nonce uint64
|
|
Contract eth_common.Address
|
|
MultiTransactionID common.MultiTransactionIDType
|
|
}
|
|
|
|
type TestTransfer struct {
|
|
TestTransaction
|
|
To eth_common.Address // [address]
|
|
Value int64
|
|
Token *token.Token
|
|
}
|
|
|
|
type TestCollectibleTransfer struct {
|
|
TestTransfer
|
|
TestCollectible
|
|
}
|
|
|
|
func SeedToToken(seed int) *token.Token {
|
|
tokenIndex := seed % len(TestTokens)
|
|
return TestTokens[tokenIndex]
|
|
}
|
|
|
|
func TestTrToToken(t *testing.T, tt *TestTransaction) (token *token.Token, isNative bool) {
|
|
// Sanity check that none of the markers changed and they should be equal to seed
|
|
require.Equal(t, tt.Timestamp, tt.BlkNumber)
|
|
|
|
tokenIndex := int(tt.Timestamp) % len(TestTokens)
|
|
isNative = testutils.SliceContains(NativeTokenIndices, tokenIndex)
|
|
|
|
return TestTokens[tokenIndex], isNative
|
|
}
|
|
|
|
func generateTestTransaction(seed int) TestTransaction {
|
|
token := SeedToToken(seed)
|
|
return TestTransaction{
|
|
Hash: eth_common.HexToHash(fmt.Sprintf("0x1%d", seed)),
|
|
ChainID: common.ChainID(token.ChainID),
|
|
From: eth_common.HexToAddress(fmt.Sprintf("0x2%d", seed)),
|
|
Timestamp: int64(seed),
|
|
BlkNumber: int64(seed),
|
|
Success: true,
|
|
Nonce: uint64(seed),
|
|
// In practice this is last20Bytes(Keccak256(RLP(From, nonce)))
|
|
Contract: eth_common.HexToAddress(fmt.Sprintf("0x4%d", seed)),
|
|
MultiTransactionID: common.NoMultiTransactionID,
|
|
}
|
|
}
|
|
|
|
func generateTestTransfer(seed int) TestTransfer {
|
|
tokenIndex := seed % len(TestTokens)
|
|
token := TestTokens[tokenIndex]
|
|
return TestTransfer{
|
|
TestTransaction: generateTestTransaction(seed),
|
|
To: eth_common.HexToAddress(fmt.Sprintf("0x3%d", seed)),
|
|
Value: int64(seed),
|
|
Token: token,
|
|
}
|
|
}
|
|
|
|
// Will be used in tests to generate a collectible transfer
|
|
// nolint:unused
|
|
func generateTestCollectibleTransfer(seed int) TestCollectibleTransfer {
|
|
collectibleIndex := seed % len(TestCollectibles)
|
|
collectible := TestCollectibles[collectibleIndex]
|
|
tr := TestCollectibleTransfer{
|
|
TestTransfer: TestTransfer{
|
|
TestTransaction: generateTestTransaction(seed),
|
|
To: eth_common.HexToAddress(fmt.Sprintf("0x3%d", seed)),
|
|
Value: int64(seed),
|
|
Token: &token.Token{
|
|
Address: collectible.TokenAddress,
|
|
Name: "Collectible",
|
|
ChainID: uint64(collectible.ChainID),
|
|
},
|
|
},
|
|
TestCollectible: collectible,
|
|
}
|
|
tr.TestTransaction.ChainID = collectible.ChainID
|
|
return tr
|
|
}
|
|
|
|
func GenerateTestSendMultiTransaction(tr TestTransfer) MultiTransaction {
|
|
return MultiTransaction{
|
|
ID: multiTransactionIDGenerator(),
|
|
Type: MultiTransactionSend,
|
|
FromAddress: tr.From,
|
|
ToAddress: tr.To,
|
|
FromAsset: tr.Token.Symbol,
|
|
ToAsset: tr.Token.Symbol,
|
|
FromAmount: (*hexutil.Big)(big.NewInt(tr.Value)),
|
|
ToAmount: (*hexutil.Big)(big.NewInt(0)),
|
|
Timestamp: uint64(tr.Timestamp),
|
|
}
|
|
}
|
|
|
|
func GenerateTestSwapMultiTransaction(tr TestTransfer, toToken string, toAmount int64) MultiTransaction {
|
|
return MultiTransaction{
|
|
ID: multiTransactionIDGenerator(),
|
|
Type: MultiTransactionSwap,
|
|
FromAddress: tr.From,
|
|
ToAddress: tr.To,
|
|
FromAsset: tr.Token.Symbol,
|
|
ToAsset: toToken,
|
|
FromAmount: (*hexutil.Big)(big.NewInt(tr.Value)),
|
|
ToAmount: (*hexutil.Big)(big.NewInt(toAmount)),
|
|
Timestamp: uint64(tr.Timestamp),
|
|
}
|
|
}
|
|
|
|
func GenerateTestBridgeMultiTransaction(fromTr, toTr TestTransfer) MultiTransaction {
|
|
return MultiTransaction{
|
|
ID: multiTransactionIDGenerator(),
|
|
Type: MultiTransactionBridge,
|
|
FromAddress: fromTr.From,
|
|
ToAddress: toTr.To,
|
|
FromAsset: fromTr.Token.Symbol,
|
|
ToAsset: toTr.Token.Symbol,
|
|
FromAmount: (*hexutil.Big)(big.NewInt(fromTr.Value)),
|
|
ToAmount: (*hexutil.Big)(big.NewInt(toTr.Value)),
|
|
Timestamp: uint64(fromTr.Timestamp),
|
|
}
|
|
}
|
|
|
|
func GenerateTestApproveMultiTransaction(tr TestTransfer) MultiTransaction {
|
|
return MultiTransaction{
|
|
ID: multiTransactionIDGenerator(),
|
|
Type: MultiTransactionApprove,
|
|
FromAddress: tr.From,
|
|
ToAddress: tr.To,
|
|
FromAsset: tr.Token.Symbol,
|
|
ToAsset: tr.Token.Symbol,
|
|
FromAmount: (*hexutil.Big)(big.NewInt(tr.Value)),
|
|
ToAmount: (*hexutil.Big)(big.NewInt(0)),
|
|
Timestamp: uint64(tr.Timestamp),
|
|
}
|
|
}
|
|
|
|
// GenerateTestTransfers will generate transaction based on the TestTokens index and roll over if there are more than
|
|
// len(TestTokens) transactions
|
|
func GenerateTestTransfers(tb testing.TB, db *sql.DB, firstStartIndex int, count int) (result []TestTransfer, fromAddresses, toAddresses []eth_common.Address) {
|
|
for i := firstStartIndex; i < (firstStartIndex + count); i++ {
|
|
tr := generateTestTransfer(i)
|
|
fromAddresses = append(fromAddresses, tr.From)
|
|
toAddresses = append(toAddresses, tr.To)
|
|
result = append(result, tr)
|
|
}
|
|
return
|
|
}
|
|
|
|
type TestCollectible struct {
|
|
TokenAddress eth_common.Address
|
|
TokenID *big.Int
|
|
ChainID common.ChainID
|
|
}
|
|
|
|
var TestCollectibles = []TestCollectible{
|
|
TestCollectible{
|
|
TokenAddress: eth_common.HexToAddress("0x97a04fda4d97c6e3547d66b572e29f4a4ff40392"),
|
|
TokenID: big.NewInt(1),
|
|
ChainID: 1,
|
|
},
|
|
TestCollectible{ // Same token ID as above but different address
|
|
TokenAddress: eth_common.HexToAddress("0x2cec8879915cdbd80c88d8b1416aa9413a24ddfa"),
|
|
TokenID: big.NewInt(1),
|
|
ChainID: 1,
|
|
},
|
|
TestCollectible{ // TokenID (big.Int) value 0 might be problematic if not handled properly
|
|
TokenAddress: eth_common.HexToAddress("0x97a04fda4d97c6e3547d66b572e29f4a4ff4ABCD"),
|
|
TokenID: big.NewInt(0),
|
|
ChainID: 420,
|
|
},
|
|
TestCollectible{
|
|
TokenAddress: eth_common.HexToAddress("0x1dea7a3e04849840c0eb15fd26a55f6c40c4a69b"),
|
|
TokenID: big.NewInt(11),
|
|
ChainID: 5,
|
|
},
|
|
TestCollectible{ // Same address as above but different token ID
|
|
TokenAddress: eth_common.HexToAddress("0x1dea7a3e04849840c0eb15fd26a55f6c40c4a69b"),
|
|
TokenID: big.NewInt(12),
|
|
ChainID: 5,
|
|
},
|
|
}
|
|
|
|
var EthMainnet = token.Token{
|
|
Address: eth_common.HexToAddress("0x"),
|
|
Name: "Ether",
|
|
Symbol: "ETH",
|
|
ChainID: 1,
|
|
}
|
|
|
|
var EthSepolia = token.Token{
|
|
Address: eth_common.HexToAddress("0x"),
|
|
Name: "Ether",
|
|
Symbol: "ETH",
|
|
ChainID: 11155111,
|
|
}
|
|
|
|
var EthOptimism = token.Token{
|
|
Address: eth_common.HexToAddress("0x"),
|
|
Name: "Ether",
|
|
Symbol: "ETH",
|
|
ChainID: 10,
|
|
}
|
|
|
|
var UsdcMainnet = token.Token{
|
|
Address: eth_common.HexToAddress("0xa0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"),
|
|
Name: "USD Coin",
|
|
Symbol: "USDC",
|
|
ChainID: 1,
|
|
}
|
|
|
|
var UsdcSepolia = token.Token{
|
|
Address: eth_common.HexToAddress("0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238"),
|
|
Name: "USD Coin",
|
|
Symbol: "USDC",
|
|
Decimals: 6,
|
|
ChainID: 11155111,
|
|
}
|
|
|
|
var UsdcOptimism = token.Token{
|
|
Address: eth_common.HexToAddress("0x7f5c764cbc14f9669b88837ca1490cca17c31607"),
|
|
Name: "USD Coin",
|
|
Symbol: "USDC",
|
|
ChainID: 10,
|
|
}
|
|
|
|
var SntMainnet = token.Token{
|
|
Address: eth_common.HexToAddress("0x744d70fdbe2ba4cf95131626614a1763df805b9e"),
|
|
Name: "Status Network Token",
|
|
Symbol: "SNT",
|
|
ChainID: 1,
|
|
}
|
|
|
|
var DaiMainnet = 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/Sepolia, ETH/Optimism, USDC/Mainnet, USDC/Sepolia, USDC/Optimism, SNT/Mainnet, DAI/Mainnet, DAI/Sepolia
|
|
var TestTokens = []*token.Token{
|
|
&EthMainnet, &EthSepolia, &EthOptimism, &UsdcMainnet, &UsdcSepolia, &UsdcOptimism, &SntMainnet, &DaiMainnet, &DaiSepolia,
|
|
}
|
|
|
|
func LookupTokenIdentity(chainID uint64, address eth_common.Address, native bool) *token.Token {
|
|
for _, token := range TestTokens {
|
|
if token.ChainID == chainID && token.Address == address && token.IsNative() == native {
|
|
return token
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
var NativeTokenIndices = []int{0, 1, 2}
|
|
|
|
func InsertTestTransfer(tb testing.TB, db *sql.DB, address eth_common.Address, tr *TestTransfer) {
|
|
token := TestTokens[int(tr.Timestamp)%len(TestTokens)]
|
|
InsertTestTransferWithOptions(tb, db, address, tr, &TestTransferOptions{
|
|
TokenAddress: token.Address,
|
|
})
|
|
}
|
|
|
|
type TestTransferOptions struct {
|
|
TokenAddress eth_common.Address
|
|
TokenID *big.Int
|
|
NullifyAddresses []eth_common.Address
|
|
Tx *types.Transaction
|
|
Receipt *types.Receipt
|
|
}
|
|
|
|
func GenerateTxField(data []byte) *types.Transaction {
|
|
return types.NewTx(&types.DynamicFeeTx{
|
|
Data: data,
|
|
})
|
|
}
|
|
|
|
func InsertTestTransferWithOptions(tb testing.TB, db *sql.DB, address eth_common.Address, tr *TestTransfer, opt *TestTransferOptions) {
|
|
var (
|
|
tx *sql.Tx
|
|
)
|
|
tx, err := db.Begin()
|
|
require.NoError(tb, err)
|
|
defer func() {
|
|
if err == nil {
|
|
err = tx.Commit()
|
|
return
|
|
}
|
|
_ = tx.Rollback()
|
|
}()
|
|
|
|
blkHash := eth_common.HexToHash("4")
|
|
|
|
block := blockDBFields{
|
|
chainID: uint64(tr.ChainID),
|
|
account: address,
|
|
blockNumber: big.NewInt(tr.BlkNumber),
|
|
blockHash: blkHash,
|
|
}
|
|
|
|
// Respect `FOREIGN KEY(network_id,address,blk_hash)` of `transfers` table
|
|
err = insertBlockDBFields(tx, block)
|
|
require.NoError(tb, err)
|
|
|
|
receiptStatus := uint64(0)
|
|
if tr.Success {
|
|
receiptStatus = 1
|
|
}
|
|
|
|
tokenType := "eth"
|
|
if (opt.TokenAddress != eth_common.Address{}) {
|
|
if opt.TokenID == nil {
|
|
tokenType = "erc20"
|
|
} else {
|
|
tokenType = "erc721"
|
|
}
|
|
}
|
|
|
|
// Workaround to simulate writing of NULL values for addresses
|
|
txTo := &tr.To
|
|
txFrom := &tr.From
|
|
for i := 0; i < len(opt.NullifyAddresses); i++ {
|
|
if opt.NullifyAddresses[i] == tr.To {
|
|
txTo = nil
|
|
}
|
|
if opt.NullifyAddresses[i] == tr.From {
|
|
txFrom = nil
|
|
}
|
|
}
|
|
|
|
transfer := transferDBFields{
|
|
chainID: uint64(tr.ChainID),
|
|
id: tr.Hash,
|
|
txHash: &tr.Hash,
|
|
address: address,
|
|
blockHash: blkHash,
|
|
blockNumber: big.NewInt(tr.BlkNumber),
|
|
sender: tr.From,
|
|
transferType: common.Type(tokenType),
|
|
timestamp: uint64(tr.Timestamp),
|
|
multiTransactionID: tr.MultiTransactionID,
|
|
baseGasFees: "0x0",
|
|
receiptStatus: &receiptStatus,
|
|
txValue: big.NewInt(tr.Value),
|
|
txFrom: txFrom,
|
|
txTo: txTo,
|
|
txNonce: &tr.Nonce,
|
|
tokenAddress: &opt.TokenAddress,
|
|
contractAddress: &tr.Contract,
|
|
tokenID: opt.TokenID,
|
|
transaction: opt.Tx,
|
|
receipt: opt.Receipt,
|
|
}
|
|
err = updateOrInsertTransfersDBFields(tx, []transferDBFields{transfer})
|
|
require.NoError(tb, err)
|
|
}
|
|
|
|
func InsertTestPendingTransaction(tb testing.TB, db *sql.DB, tr *TestTransfer) {
|
|
_, err := db.Exec(`
|
|
INSERT INTO pending_transactions (network_id, hash, timestamp, from_address, to_address,
|
|
symbol, gas_price, gas_limit, value, data, type, additional_data, multi_transaction_id
|
|
) VALUES (?, ?, ?, ?, ?, 'ETH', 0, 0, ?, '', 'eth', '', ?)`,
|
|
tr.ChainID, tr.Hash, tr.Timestamp, tr.From, tr.To, (*bigint.SQLBigIntBytes)(big.NewInt(tr.Value)), tr.MultiTransactionID)
|
|
require.NoError(tb, err)
|
|
}
|
|
|
|
func InsertTestMultiTransaction(tb testing.TB, db *sql.DB, tr *MultiTransaction) common.MultiTransactionIDType {
|
|
if tr.FromAsset == "" {
|
|
tr.FromAsset = testutils.EthSymbol
|
|
}
|
|
if tr.ToAsset == "" {
|
|
tr.ToAsset = testutils.EthSymbol
|
|
}
|
|
|
|
tr.ID = multiTransactionIDGenerator()
|
|
multiTxDB := NewMultiTransactionDB(db)
|
|
err := multiTxDB.CreateMultiTransaction(tr)
|
|
require.NoError(tb, err)
|
|
return tr.ID
|
|
}
|
|
|
|
// For using in tests only outside the package
|
|
func SaveTransfersMarkBlocksLoaded(database *Database, chainID uint64, address eth_common.Address, transfers []Transfer, blocks []*big.Int) error {
|
|
return saveTransfersMarkBlocksLoaded(database.client, chainID, address, transfers, blocks)
|
|
}
|
|
|
|
func SetMultiTransactionIDGenerator(f func() common.MultiTransactionIDType) {
|
|
multiTransactionIDGenerator = f
|
|
}
|
|
|
|
func StaticIDCounter() (f func() common.MultiTransactionIDType) {
|
|
var i int
|
|
f = func() common.MultiTransactionIDType {
|
|
i++
|
|
return common.MultiTransactionIDType(i)
|
|
}
|
|
return
|
|
}
|
|
|
|
type InMemMultiTransactionStorage struct {
|
|
storage map[common.MultiTransactionIDType]*MultiTransaction
|
|
}
|
|
|
|
func NewInMemMultiTransactionStorage() *InMemMultiTransactionStorage {
|
|
return &InMemMultiTransactionStorage{
|
|
storage: make(map[common.MultiTransactionIDType]*MultiTransaction),
|
|
}
|
|
}
|
|
|
|
func (s *InMemMultiTransactionStorage) CreateMultiTransaction(multiTx *MultiTransaction) error {
|
|
s.storage[multiTx.ID] = multiTx
|
|
return nil
|
|
}
|
|
|
|
func (s *InMemMultiTransactionStorage) GetMultiTransaction(id common.MultiTransactionIDType) (*MultiTransaction, error) {
|
|
multiTx, ok := s.storage[id]
|
|
if !ok {
|
|
return nil, nil
|
|
}
|
|
return multiTx, nil
|
|
}
|
|
|
|
func (s *InMemMultiTransactionStorage) UpdateMultiTransaction(multiTx *MultiTransaction) error {
|
|
s.storage[multiTx.ID] = multiTx
|
|
return nil
|
|
}
|
|
|
|
func (s *InMemMultiTransactionStorage) DeleteMultiTransaction(id common.MultiTransactionIDType) error {
|
|
delete(s.storage, id)
|
|
return nil
|
|
}
|
|
|
|
func (s *InMemMultiTransactionStorage) ReadMultiTransactions(details *MultiTxDetails) ([]*MultiTransaction, error) {
|
|
var multiTxs []*MultiTransaction
|
|
for _, multiTx := range s.storage {
|
|
if len(details.IDs) > 0 && !testutils.SliceContains(details.IDs, multiTx.ID) {
|
|
continue
|
|
}
|
|
|
|
if (details.AnyAddress != eth_common.Address{}) &&
|
|
(multiTx.FromAddress != details.AnyAddress && multiTx.ToAddress != details.AnyAddress) {
|
|
continue
|
|
}
|
|
|
|
if (details.FromAddress != eth_common.Address{}) && multiTx.FromAddress != details.FromAddress {
|
|
continue
|
|
}
|
|
|
|
if (details.ToAddress != eth_common.Address{}) && multiTx.ToAddress != details.ToAddress {
|
|
continue
|
|
}
|
|
|
|
if details.ToChainID != 0 && multiTx.ToNetworkID != details.ToChainID {
|
|
continue
|
|
}
|
|
|
|
if details.Type != MultiTransactionDBTypeInvalid && multiTx.Type != mtDBTypeToMTType(details.Type) {
|
|
continue
|
|
}
|
|
|
|
if details.CrossTxID != "" && multiTx.CrossTxID != details.CrossTxID {
|
|
continue
|
|
}
|
|
|
|
multiTxs = append(multiTxs, multiTx)
|
|
}
|
|
return multiTxs, nil
|
|
}
|