package transactions import ( "fmt" "math/big" "reflect" "testing" "time" "github.com/golang/mock/gomock" "github.com/stretchr/testify/suite" "github.com/ethereum/go-ethereum/common" "github.com/ethereum/go-ethereum/common/hexutil" gethtypes "github.com/ethereum/go-ethereum/core/types" gethcrypto "github.com/ethereum/go-ethereum/crypto" gethparams "github.com/ethereum/go-ethereum/params" "github.com/ethereum/go-ethereum/rlp" gethrpc "github.com/ethereum/go-ethereum/rpc" "github.com/status-im/status-go/account" "github.com/status-im/status-go/eth-node/crypto" "github.com/status-im/status-go/eth-node/types" "github.com/status-im/status-go/params" "github.com/status-im/status-go/rpc" "github.com/status-im/status-go/sqlite" "github.com/status-im/status-go/t/utils" "github.com/status-im/status-go/transactions/fake" ) func TestTransactorSuite(t *testing.T) { utils.Init() suite.Run(t, new(TransactorSuite)) } type TransactorSuite struct { suite.Suite server *gethrpc.Server client *gethrpc.Client txServiceMockCtrl *gomock.Controller txServiceMock *fake.MockPublicTransactionPoolAPI nodeConfig *params.NodeConfig manager *Transactor } func (s *TransactorSuite) SetupTest() { s.txServiceMockCtrl = gomock.NewController(s.T()) s.server, s.txServiceMock = fake.NewTestServer(s.txServiceMockCtrl) s.client = gethrpc.DialInProc(s.server) // expected by simulated backend chainID := gethparams.AllEthashProtocolChanges.ChainID.Uint64() db, err := sqlite.OpenUnecryptedDB(sqlite.InMemoryPath) // dummy to make rpc.Client happy s.Require().NoError(err) rpcClient, _ := rpc.NewClient(s.client, chainID, params.UpstreamRPCConfig{}, nil, db) rpcClient.UpstreamChainID = chainID nodeConfig, err := utils.MakeTestNodeConfigWithDataDir("", "/tmp", chainID) s.Require().NoError(err) s.nodeConfig = nodeConfig s.manager = NewTransactor() s.manager.sendTxTimeout = time.Second s.manager.SetNetworkID(chainID) s.manager.SetRPC(rpcClient, time.Second) } func (s *TransactorSuite) TearDownTest() { s.txServiceMockCtrl.Finish() s.server.Stop() s.client.Close() } var ( testGas = hexutil.Uint64(defaultGas + 1) testGasPrice = (*hexutil.Big)(big.NewInt(10)) testNonce = hexutil.Uint64(10) ) func (s *TransactorSuite) setupTransactionPoolAPI(args SendTxArgs, returnNonce, resultNonce hexutil.Uint64, account *account.SelectedExtKey, txErr error) { // Expect calls to gas functions only if there are no user defined values. // And also set the expected gas and gas price for RLP encoding the expected tx. var usedGas hexutil.Uint64 var usedGasPrice *big.Int s.txServiceMock.EXPECT().GetTransactionCount(gomock.Any(), gomock.Eq(common.Address(account.Address)), gethrpc.PendingBlockNumber).Return(&returnNonce, nil) if !args.IsDynamicFeeTx() { if args.GasPrice == nil { usedGasPrice = (*big.Int)(testGasPrice) s.txServiceMock.EXPECT().GasPrice(gomock.Any()).Return(testGasPrice, nil) } else { usedGasPrice = (*big.Int)(args.GasPrice) } if args.Gas == nil { s.txServiceMock.EXPECT().EstimateGas(gomock.Any(), gomock.Any()).Return(testGas, nil) usedGas = testGas } else { usedGas = *args.Gas } } // Prepare the transaction and RLP encode it. data := s.rlpEncodeTx(args, s.nodeConfig, account, &resultNonce, usedGas, usedGasPrice) // Expect the RLP encoded transaction. s.txServiceMock.EXPECT().SendRawTransaction(gomock.Any(), data).Return(common.Hash{}, txErr) } func (s *TransactorSuite) rlpEncodeTx(args SendTxArgs, config *params.NodeConfig, account *account.SelectedExtKey, nonce *hexutil.Uint64, gas hexutil.Uint64, gasPrice *big.Int) hexutil.Bytes { var txData gethtypes.TxData to := common.Address(*args.To) if args.IsDynamicFeeTx() { gasTipCap := (*big.Int)(args.MaxPriorityFeePerGas) gasFeeCap := (*big.Int)(args.MaxFeePerGas) txData = &gethtypes.DynamicFeeTx{ Nonce: uint64(*nonce), Gas: uint64(gas), GasTipCap: gasTipCap, GasFeeCap: gasFeeCap, To: &to, Value: args.Value.ToInt(), Data: args.GetInput(), } } else { txData = &gethtypes.LegacyTx{ Nonce: uint64(*nonce), GasPrice: gasPrice, Gas: uint64(gas), To: &to, Value: args.Value.ToInt(), Data: args.GetInput(), } } newTx := gethtypes.NewTx(txData) chainID := big.NewInt(int64(s.nodeConfig.NetworkID)) signedTx, err := gethtypes.SignTx(newTx, gethtypes.NewLondonSigner(chainID), account.AccountKey.PrivateKey) s.NoError(err) data, err := signedTx.MarshalBinary() s.NoError(err) return hexutil.Bytes(data) } func (s *TransactorSuite) TestGasValues() { key, _ := gethcrypto.GenerateKey() selectedAccount := &account.SelectedExtKey{ Address: account.FromAddress(utils.TestConfig.Account1.WalletAddress), AccountKey: &types.Key{PrivateKey: key}, } testCases := []struct { name string gas *hexutil.Uint64 gasPrice *hexutil.Big maxFeePerGas *hexutil.Big maxPriorityFeePerGas *hexutil.Big }{ { "noGasDef", nil, nil, nil, nil, }, { "gasDefined", &testGas, nil, nil, nil, }, { "gasPriceDefined", nil, testGasPrice, nil, nil, }, { "nilSignTransactionSpecificArgs", nil, nil, nil, nil, }, { "maxFeeAndPriorityset", nil, nil, testGasPrice, testGasPrice, }, } for _, testCase := range testCases { s.T().Run(testCase.name, func(t *testing.T) { s.SetupTest() args := SendTxArgs{ From: account.FromAddress(utils.TestConfig.Account1.WalletAddress), To: account.ToAddress(utils.TestConfig.Account2.WalletAddress), Gas: testCase.gas, GasPrice: testCase.gasPrice, MaxFeePerGas: testCase.maxFeePerGas, MaxPriorityFeePerGas: testCase.maxPriorityFeePerGas, } s.setupTransactionPoolAPI(args, testNonce, testNonce, selectedAccount, nil) hash, err := s.manager.SendTransaction(args, selectedAccount) s.NoError(err) s.False(reflect.DeepEqual(hash, common.Hash{})) }) } } func (s *TransactorSuite) TestArgsValidation() { args := SendTxArgs{ From: account.FromAddress(utils.TestConfig.Account1.WalletAddress), To: account.ToAddress(utils.TestConfig.Account2.WalletAddress), Data: types.HexBytes([]byte{0x01, 0x02}), Input: types.HexBytes([]byte{0x02, 0x01}), } s.False(args.Valid()) selectedAccount := &account.SelectedExtKey{ Address: account.FromAddress(utils.TestConfig.Account1.WalletAddress), } _, err := s.manager.SendTransaction(args, selectedAccount) s.EqualError(err, ErrInvalidSendTxArgs.Error()) } func (s *TransactorSuite) TestAccountMismatch() { args := SendTxArgs{ From: account.FromAddress(utils.TestConfig.Account1.WalletAddress), To: account.ToAddress(utils.TestConfig.Account2.WalletAddress), } var err error // missing account _, err = s.manager.SendTransaction(args, nil) s.EqualError(err, account.ErrNoAccountSelected.Error()) // mismatched accounts selectedAccount := &account.SelectedExtKey{ Address: account.FromAddress(utils.TestConfig.Account2.WalletAddress), } _, err = s.manager.SendTransaction(args, selectedAccount) s.EqualError(err, ErrInvalidTxSender.Error()) } func (s *TransactorSuite) TestSendTransactionWithSignature() { privKey, err := crypto.GenerateKey() s.Require().NoError(err) address := crypto.PubkeyToAddress(privKey.PublicKey) scenarios := []struct { nonceFromNetwork hexutil.Uint64 txNonce hexutil.Uint64 expectError bool }{ { nonceFromNetwork: hexutil.Uint64(0), txNonce: hexutil.Uint64(0), expectError: false, }, { nonceFromNetwork: hexutil.Uint64(0), txNonce: hexutil.Uint64(1), expectError: true, }, } for _, localScenario := range scenarios { // to satisfy gosec: C601 checks scenario := localScenario desc := fmt.Sprintf("nonceFromNetwork: %d, tx nonce: %d, expect error: %v", scenario.nonceFromNetwork, scenario.txNonce, scenario.expectError) s.T().Run(desc, func(t *testing.T) { nonce := scenario.txNonce from := address to := address value := (*hexutil.Big)(big.NewInt(10)) gas := hexutil.Uint64(21000) gasPrice := (*hexutil.Big)(big.NewInt(2000000000)) data := []byte{} chainID := big.NewInt(int64(s.nodeConfig.NetworkID)) args := SendTxArgs{ From: from, To: &to, Gas: &gas, GasPrice: gasPrice, Value: value, Nonce: &nonce, Data: nil, } // simulate transaction signed externally signer := gethtypes.NewLondonSigner(chainID) tx := gethtypes.NewTransaction(uint64(nonce), common.Address(to), (*big.Int)(value), uint64(gas), (*big.Int)(gasPrice), data) hash := signer.Hash(tx) sig, err := gethcrypto.Sign(hash[:], privKey) s.Require().NoError(err) txWithSig, err := tx.WithSignature(signer, sig) s.Require().NoError(err) expectedEncodedTx, err := rlp.EncodeToBytes(txWithSig) s.Require().NoError(err) s.txServiceMock.EXPECT(). GetTransactionCount(gomock.Any(), common.Address(address), gethrpc.PendingBlockNumber). Return(&scenario.nonceFromNetwork, nil) if !scenario.expectError { s.txServiceMock.EXPECT(). SendRawTransaction(gomock.Any(), hexutil.Bytes(expectedEncodedTx)). Return(common.Hash{}, nil) } tx, err = s.manager.BuildTransactionWithSignature(s.nodeConfig.NetworkID, args, sig) if scenario.expectError { s.Error(err) } else { s.NoError(err) _, err = s.manager.SendTransactionWithSignature(common.Address(args.From), args.Symbol, args.MultiTransactionID, tx) if scenario.expectError { s.Error(err) } else { s.NoError(err) } } }) } } func (s *TransactorSuite) TestSendTransactionWithSignature_InvalidSignature() { args := SendTxArgs{} _, err := s.manager.BuildTransactionWithSignature(1, args, []byte{}) s.Equal(ErrInvalidSignatureSize, err) } func (s *TransactorSuite) TestHashTransaction() { privKey, err := crypto.GenerateKey() s.Require().NoError(err) address := crypto.PubkeyToAddress(privKey.PublicKey) remoteNonce := hexutil.Uint64(1) txNonce := hexutil.Uint64(0) from := address to := address value := (*hexutil.Big)(big.NewInt(10)) gas := hexutil.Uint64(21000) gasPrice := (*hexutil.Big)(big.NewInt(2000000000)) args := SendTxArgs{ From: from, To: &to, Gas: &gas, GasPrice: gasPrice, Value: value, Nonce: &txNonce, Data: nil, } s.txServiceMock.EXPECT(). GetTransactionCount(gomock.Any(), common.Address(address), gethrpc.PendingBlockNumber). Return(&remoteNonce, nil) newArgs, hash, err := s.manager.HashTransaction(args) s.Require().NoError(err) // args should be updated with the right nonce s.NotEqual(*args.Nonce, *newArgs.Nonce) s.Equal(remoteNonce, *newArgs.Nonce) s.NotEqual(common.Hash{}, hash) }