github.com/status-im/status-go@v1.1.0/services/wallet/router/pathprocessor/processor_test.go (about)

     1  package pathprocessor
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/status-im/status-go/params"
     8  	walletCommon "github.com/status-im/status-go/services/wallet/common"
     9  	"github.com/status-im/status-go/services/wallet/token"
    10  
    11  	"github.com/stretchr/testify/assert"
    12  )
    13  
    14  var mainnet = params.Network{
    15  	ChainID:                walletCommon.EthereumMainnet,
    16  	ChainName:              "Mainnet",
    17  	RPCURL:                 "https://eth-archival.rpc.grove.city/v1/",
    18  	FallbackURL:            "https://mainnet.infura.io/v3/",
    19  	BlockExplorerURL:       "https://etherscan.io/",
    20  	IconURL:                "network/Network=Ethereum",
    21  	ChainColor:             "#627EEA",
    22  	ShortName:              "eth",
    23  	NativeCurrencyName:     "Ether",
    24  	NativeCurrencySymbol:   "ETH",
    25  	NativeCurrencyDecimals: 18,
    26  	IsTest:                 false,
    27  	Layer:                  1,
    28  	Enabled:                true,
    29  	RelatedChainID:         walletCommon.EthereumMainnet,
    30  }
    31  
    32  var optimism = params.Network{
    33  	ChainID:                walletCommon.OptimismMainnet,
    34  	ChainName:              "Optimism",
    35  	RPCURL:                 "https://optimism-mainnet.rpc.grove.city/v1/",
    36  	FallbackURL:            "https://optimism-mainnet.infura.io/v3/",
    37  	BlockExplorerURL:       "https://optimistic.etherscan.io",
    38  	IconURL:                "network/Network=Optimism",
    39  	ChainColor:             "#E90101",
    40  	ShortName:              "oeth",
    41  	NativeCurrencyName:     "Ether",
    42  	NativeCurrencySymbol:   "ETH",
    43  	NativeCurrencyDecimals: 18,
    44  	IsTest:                 false,
    45  	Layer:                  2,
    46  	Enabled:                true,
    47  	RelatedChainID:         walletCommon.OptimismMainnet,
    48  }
    49  
    50  var testEstimationMap = map[string]Estimation{
    51  	ProcessorTransferName:     {uint64(1000), nil},
    52  	ProcessorBridgeHopName:    {uint64(5000), nil},
    53  	ProcessorSwapParaswapName: {uint64(2000), nil},
    54  }
    55  
    56  type expectedResult struct {
    57  	expected      bool
    58  	expectedError error
    59  }
    60  
    61  func TestPathProcessors(t *testing.T) {
    62  	tests := []struct {
    63  		name          string
    64  		input         ProcessorInputParams
    65  		expectedError error
    66  		expected      map[string]expectedResult
    67  	}{
    68  		{
    69  			name: "Empty Input Params",
    70  			input: ProcessorInputParams{
    71  				TestsMode: true,
    72  			},
    73  			expected: map[string]expectedResult{
    74  				ProcessorTransferName: {
    75  					expected:      false,
    76  					expectedError: ErrNoChainSet,
    77  				},
    78  				ProcessorBridgeHopName: {
    79  					expected:      false,
    80  					expectedError: ErrNoChainSet,
    81  				},
    82  				ProcessorSwapParaswapName: {
    83  					expected:      false,
    84  					expectedError: ErrNoChainSet,
    85  				},
    86  			},
    87  		},
    88  		{
    89  			name: "Same Chains Set - No FormToken - No ToToken",
    90  			input: ProcessorInputParams{
    91  				TestsMode:         true,
    92  				FromChain:         &mainnet,
    93  				ToChain:           &mainnet,
    94  				TestEstimationMap: testEstimationMap,
    95  			},
    96  			expected: map[string]expectedResult{
    97  				ProcessorTransferName: {
    98  					expected:      false,
    99  					expectedError: ErrNoTokenSet,
   100  				},
   101  				ProcessorBridgeHopName: {
   102  					expected:      false,
   103  					expectedError: ErrNoTokenSet,
   104  				},
   105  				ProcessorSwapParaswapName: {
   106  					expected:      false,
   107  					expectedError: ErrToAndFromTokensMustBeSet,
   108  				},
   109  			},
   110  		},
   111  		{
   112  			name: "Same Chains Set - FormToken Set - No ToToken",
   113  			input: ProcessorInputParams{
   114  				TestsMode: true,
   115  				FromChain: &mainnet,
   116  				ToChain:   &mainnet,
   117  				FromToken: &token.Token{
   118  					Symbol: EthSymbol,
   119  				},
   120  				TestEstimationMap: testEstimationMap,
   121  			},
   122  			expected: map[string]expectedResult{
   123  				ProcessorTransferName: {
   124  					expected:      true,
   125  					expectedError: nil,
   126  				},
   127  				ProcessorBridgeHopName: {
   128  					expected:      false,
   129  					expectedError: ErrFromAndToChainsMustBeDifferent,
   130  				},
   131  				ProcessorSwapParaswapName: {
   132  					expected:      false,
   133  					expectedError: ErrToAndFromTokensMustBeSet,
   134  				},
   135  			},
   136  		},
   137  		{
   138  			name: "Same Chains Set - FormToken Set - ToToken Set - Same Tokens",
   139  			input: ProcessorInputParams{
   140  				TestsMode: true,
   141  				FromChain: &mainnet,
   142  				ToChain:   &mainnet,
   143  				FromToken: &token.Token{
   144  					Symbol: EthSymbol,
   145  				},
   146  				ToToken: &token.Token{
   147  					Symbol: EthSymbol,
   148  				},
   149  				TestEstimationMap: testEstimationMap,
   150  			},
   151  			expected: map[string]expectedResult{
   152  				ProcessorTransferName: {
   153  					expected:      false,
   154  					expectedError: ErrToTokenShouldNotBeSet,
   155  				},
   156  				ProcessorBridgeHopName: {
   157  					expected:      false,
   158  					expectedError: ErrToTokenShouldNotBeSet,
   159  				},
   160  				ProcessorSwapParaswapName: {
   161  					expected:      false,
   162  					expectedError: ErrFromAndToTokensMustBeDifferent,
   163  				},
   164  			},
   165  		},
   166  		{
   167  			name: "Same Chains Set - FormToken Set - ToToken Set - Different Tokens",
   168  			input: ProcessorInputParams{
   169  				TestsMode: true,
   170  				FromChain: &mainnet,
   171  				ToChain:   &mainnet,
   172  				FromToken: &token.Token{
   173  					Symbol: EthSymbol,
   174  				},
   175  				ToToken: &token.Token{
   176  					Symbol: UsdcSymbol,
   177  				},
   178  				TestEstimationMap: testEstimationMap,
   179  			},
   180  			expected: map[string]expectedResult{
   181  				ProcessorTransferName: {
   182  					expected:      false,
   183  					expectedError: ErrToTokenShouldNotBeSet,
   184  				},
   185  				ProcessorBridgeHopName: {
   186  					expected:      false,
   187  					expectedError: ErrToTokenShouldNotBeSet,
   188  				},
   189  				ProcessorSwapParaswapName: {
   190  					expected:      true,
   191  					expectedError: nil,
   192  				},
   193  			},
   194  		},
   195  		{
   196  			name: "Different Chains Set - No FormToken - No ToToken",
   197  			input: ProcessorInputParams{
   198  				TestsMode:         true,
   199  				FromChain:         &mainnet,
   200  				ToChain:           &optimism,
   201  				TestEstimationMap: testEstimationMap,
   202  			},
   203  			expected: map[string]expectedResult{
   204  				ProcessorTransferName: {
   205  					expected:      false,
   206  					expectedError: ErrNoTokenSet,
   207  				},
   208  				ProcessorBridgeHopName: {
   209  					expected:      false,
   210  					expectedError: ErrNoTokenSet,
   211  				},
   212  				ProcessorSwapParaswapName: {
   213  					expected:      false,
   214  					expectedError: ErrFromAndToChainsMustBeSame,
   215  				},
   216  			},
   217  		},
   218  		{
   219  			name: "Different Chains Set - FormToken Set - No ToToken",
   220  			input: ProcessorInputParams{
   221  				TestsMode: true,
   222  				FromChain: &mainnet,
   223  				ToChain:   &optimism,
   224  				FromToken: &token.Token{
   225  					Symbol: EthSymbol,
   226  				},
   227  				TestEstimationMap: testEstimationMap,
   228  			},
   229  			expected: map[string]expectedResult{
   230  				ProcessorTransferName: {
   231  					expected:      false,
   232  					expectedError: nil,
   233  				},
   234  				ProcessorBridgeHopName: {
   235  					expected:      true,
   236  					expectedError: nil,
   237  				},
   238  				ProcessorSwapParaswapName: {
   239  					expected:      false,
   240  					expectedError: ErrFromAndToChainsMustBeSame,
   241  				},
   242  			},
   243  		},
   244  		{
   245  			name: "Different Chains Set - FormToken Set - ToToken Set - Same Tokens",
   246  			input: ProcessorInputParams{
   247  				TestsMode: true,
   248  				FromChain: &mainnet,
   249  				ToChain:   &optimism,
   250  				FromToken: &token.Token{
   251  					Symbol: EthSymbol,
   252  				},
   253  				ToToken: &token.Token{
   254  					Symbol: EthSymbol,
   255  				},
   256  				TestEstimationMap: testEstimationMap,
   257  			},
   258  			expected: map[string]expectedResult{
   259  				ProcessorTransferName: {
   260  					expected:      false,
   261  					expectedError: ErrToTokenShouldNotBeSet,
   262  				},
   263  				ProcessorBridgeHopName: {
   264  					expected:      false,
   265  					expectedError: ErrToTokenShouldNotBeSet,
   266  				},
   267  				ProcessorSwapParaswapName: {
   268  					expected:      false,
   269  					expectedError: ErrFromAndToChainsMustBeSame,
   270  				},
   271  			},
   272  		},
   273  		{
   274  			name: "Different Chains Set - FormToken Set - ToToken Set - Different Tokens",
   275  			input: ProcessorInputParams{
   276  				TestsMode: true,
   277  				FromChain: &mainnet,
   278  				ToChain:   &optimism,
   279  				FromToken: &token.Token{
   280  					Symbol: EthSymbol,
   281  				},
   282  				ToToken: &token.Token{
   283  					Symbol: UsdcSymbol,
   284  				},
   285  				TestEstimationMap: testEstimationMap,
   286  			},
   287  			expected: map[string]expectedResult{
   288  				ProcessorTransferName: {
   289  					expected:      false,
   290  					expectedError: ErrToTokenShouldNotBeSet,
   291  				},
   292  				ProcessorBridgeHopName: {
   293  					expected:      false,
   294  					expectedError: ErrToTokenShouldNotBeSet,
   295  				},
   296  				ProcessorSwapParaswapName: {
   297  					expected:      false,
   298  					expectedError: ErrFromAndToChainsMustBeSame,
   299  				},
   300  			},
   301  		},
   302  	}
   303  
   304  	for _, tt := range tests {
   305  		for processorName, expResult := range tt.expected {
   306  			t.Run(fmt.Sprintf("%s[%s]", processorName, tt.name), func(t *testing.T) {
   307  
   308  				var processor PathProcessor
   309  				if processorName == ProcessorTransferName {
   310  					processor = NewTransferProcessor(nil, nil)
   311  				} else if processorName == ProcessorBridgeHopName {
   312  					processor = NewHopBridgeProcessor(nil, nil, nil, nil)
   313  				} else if processorName == ProcessorSwapParaswapName {
   314  					processor = NewSwapParaswapProcessor(nil, nil, nil)
   315  				}
   316  
   317  				assert.Equal(t, processorName, processor.Name())
   318  				result, err := processor.AvailableFor(tt.input)
   319  				if expResult.expectedError != nil {
   320  					assert.Error(t, err)
   321  				} else {
   322  					assert.NoError(t, err)
   323  				}
   324  				assert.Equal(t, expResult.expected, result)
   325  
   326  				if tt.input.TestEstimationMap != nil {
   327  					estimatedGas, err := processor.EstimateGas(tt.input)
   328  					assert.NoError(t, err)
   329  					assert.Greater(t, estimatedGas, uint64(0))
   330  
   331  					input := tt.input
   332  					input.TestEstimationMap = map[string]Estimation{
   333  						"randomName": {10000, nil},
   334  					}
   335  					estimatedGas, err = processor.EstimateGas(input)
   336  					assert.Error(t, err)
   337  					assert.Equal(t, ErrNoEstimationFound, err)
   338  					assert.Equal(t, uint64(0), estimatedGas)
   339  				} else {
   340  					estimatedGas, err := processor.EstimateGas(tt.input)
   341  					assert.Error(t, err)
   342  					assert.Equal(t, ErrNoEstimationFound, err)
   343  					assert.Equal(t, uint64(0), estimatedGas)
   344  				}
   345  			})
   346  		}
   347  	}
   348  }