github.com/0xPolygon/supernets2-node@v0.0.0-20230711153321-2fe574524eaa/test/e2e/debug_shared.go (about)

     1  package e2e
     2  
     3  import (
     4  	"context"
     5  	"encoding/json"
     6  	"fmt"
     7  	"math/big"
     8  	"os"
     9  	"strings"
    10  	"testing"
    11  
    12  	"github.com/0xPolygon/supernets2-node/hex"
    13  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/Called"
    14  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/Caller"
    15  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/ChainCallLevel1"
    16  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/ChainCallLevel2"
    17  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/ChainCallLevel3"
    18  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/ChainCallLevel4"
    19  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/Counter"
    20  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/Creates"
    21  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/ERC20"
    22  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/EmitLog"
    23  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/Revert2"
    24  	"github.com/0xPolygon/supernets2-node/test/operations"
    25  	"github.com/0xPolygon/supernets2-node/test/testutils"
    26  	"github.com/ethereum/go-ethereum"
    27  	"github.com/ethereum/go-ethereum/accounts/abi/bind"
    28  	"github.com/ethereum/go-ethereum/common"
    29  	ethTypes "github.com/ethereum/go-ethereum/core/types"
    30  	"github.com/ethereum/go-ethereum/ethclient"
    31  	"github.com/stretchr/testify/require"
    32  )
    33  
    34  const fixedTxGasLimit uint64 = 100000
    35  
    36  func createEthTransferSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
    37  	nonce, err := client.PendingNonceAt(ctx, auth.From)
    38  	require.NoError(t, err)
    39  
    40  	gasPrice, err := client.SuggestGasPrice(ctx)
    41  	require.NoError(t, err)
    42  
    43  	to := common.HexToAddress("0x1275fbb540c8efc58b812ba83b0d0b8b9917ae98")
    44  
    45  	gas, err := client.EstimateGas(ctx, ethereum.CallMsg{
    46  		From: auth.From,
    47  		To:   &to,
    48  	})
    49  	require.NoError(t, err)
    50  
    51  	tx := ethTypes.NewTx(&ethTypes.LegacyTx{
    52  		Nonce:    nonce,
    53  		To:       &to,
    54  		GasPrice: gasPrice,
    55  		Gas:      gas,
    56  	})
    57  
    58  	return auth.Signer(auth.From, tx)
    59  }
    60  
    61  func createScDeploySignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
    62  	nonce, err := client.PendingNonceAt(ctx, auth.From)
    63  	require.NoError(t, err)
    64  
    65  	gasPrice, err := client.SuggestGasPrice(ctx)
    66  	require.NoError(t, err)
    67  
    68  	scByteCode, err := testutils.ReadBytecode("Counter/Counter.bin")
    69  	require.NoError(t, err)
    70  	data := common.Hex2Bytes(scByteCode)
    71  
    72  	gas, err := client.EstimateGas(ctx, ethereum.CallMsg{
    73  		From: auth.From,
    74  		Data: data,
    75  	})
    76  	require.NoError(t, err)
    77  
    78  	tx := ethTypes.NewTx(&ethTypes.LegacyTx{
    79  		Nonce:    nonce,
    80  		GasPrice: gasPrice,
    81  		Gas:      gas,
    82  		Data:     data,
    83  	})
    84  
    85  	return auth.Signer(auth.From, tx)
    86  }
    87  
    88  func prepareScCall(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client) (map[string]interface{}, error) {
    89  	_, tx, sc, err := EmitLog.DeployEmitLog(auth, client)
    90  	require.NoError(t, err)
    91  
    92  	err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
    93  	require.NoError(t, err)
    94  
    95  	return map[string]interface{}{
    96  		"sc": sc,
    97  	}, nil
    98  }
    99  
   100  func createScCallSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   101  	scInterface := customData["sc"]
   102  	sc := scInterface.(*EmitLog.EmitLog)
   103  
   104  	opts := *auth
   105  	opts.NoSend = true
   106  
   107  	tx, err := sc.EmitLogs(&opts)
   108  	require.NoError(t, err)
   109  
   110  	return tx, nil
   111  }
   112  
   113  func prepareERC20Transfer(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client) (map[string]interface{}, error) {
   114  	_, tx, sc, err := ERC20.DeployERC20(auth, client, "MyToken", "MT")
   115  	require.NoError(t, err)
   116  
   117  	err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   118  	require.NoError(t, err)
   119  
   120  	tx, err = sc.Mint(auth, big.NewInt(1000000000))
   121  	require.NoError(t, err)
   122  
   123  	err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   124  	require.NoError(t, err)
   125  
   126  	return map[string]interface{}{
   127  		"sc": sc,
   128  	}, nil
   129  }
   130  
   131  func createERC20TransferSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   132  	scInterface := customData["sc"]
   133  	sc := scInterface.(*ERC20.ERC20)
   134  
   135  	opts := *auth
   136  	opts.NoSend = true
   137  
   138  	to := common.HexToAddress("0x1275fbb540c8efc58b812ba83b0d0b8b9917ae98")
   139  
   140  	tx, err := sc.Transfer(&opts, to, big.NewInt(123456))
   141  	require.NoError(t, err)
   142  
   143  	return tx, nil
   144  }
   145  
   146  func createScDeployRevertedSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   147  	nonce, err := client.PendingNonceAt(ctx, auth.From)
   148  	require.NoError(t, err)
   149  
   150  	gasPrice, err := client.SuggestGasPrice(ctx)
   151  	require.NoError(t, err)
   152  
   153  	scByteCode, err := testutils.ReadBytecode("Revert/Revert.bin")
   154  	require.NoError(t, err)
   155  	data := common.Hex2Bytes(scByteCode)
   156  
   157  	tx := ethTypes.NewTx(&ethTypes.LegacyTx{
   158  		Nonce:    nonce,
   159  		GasPrice: gasPrice,
   160  		Gas:      fixedTxGasLimit,
   161  		Data:     data,
   162  	})
   163  
   164  	return auth.Signer(auth.From, tx)
   165  }
   166  
   167  func prepareScCallReverted(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client) (map[string]interface{}, error) {
   168  	_, tx, sc, err := Revert2.DeployRevert2(auth, client)
   169  	require.NoError(t, err)
   170  
   171  	err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   172  	require.NoError(t, err)
   173  
   174  	return map[string]interface{}{
   175  		"sc": sc,
   176  	}, nil
   177  }
   178  
   179  func createScCallRevertedSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   180  	scInterface := customData["sc"]
   181  	sc := scInterface.(*Revert2.Revert2)
   182  
   183  	opts := *auth
   184  	opts.NoSend = true
   185  	opts.GasLimit = fixedTxGasLimit
   186  
   187  	tx, err := sc.GenerateError(&opts)
   188  	require.NoError(t, err)
   189  
   190  	return tx, nil
   191  }
   192  
   193  func prepareERC20TransferReverted(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client) (map[string]interface{}, error) {
   194  	_, tx, sc, err := ERC20.DeployERC20(auth, client, "MyToken2", "MT2")
   195  	require.NoError(t, err)
   196  
   197  	err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   198  	require.NoError(t, err)
   199  
   200  	err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   201  	require.NoError(t, err)
   202  
   203  	return map[string]interface{}{
   204  		"sc": sc,
   205  	}, nil
   206  }
   207  
   208  func createERC20TransferRevertedSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   209  	scInterface := customData["sc"]
   210  	sc := scInterface.(*ERC20.ERC20)
   211  
   212  	opts := *auth
   213  	opts.NoSend = true
   214  	opts.GasLimit = fixedTxGasLimit
   215  
   216  	to := common.HexToAddress("0x1275fbb540c8efc58b812ba83b0d0b8b9917ae98")
   217  
   218  	tx, err := sc.Transfer(&opts, to, big.NewInt(123456))
   219  	require.NoError(t, err)
   220  
   221  	return tx, nil
   222  }
   223  
   224  func prepareCreate(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client) (map[string]interface{}, error) {
   225  	_, tx, sc, err := Creates.DeployCreates(auth, client)
   226  	require.NoError(t, err)
   227  
   228  	err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   229  	require.NoError(t, err)
   230  
   231  	return map[string]interface{}{
   232  		"sc": sc,
   233  	}, nil
   234  }
   235  
   236  func createCreateSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   237  	scInterface := customData["sc"]
   238  	sc := scInterface.(*Creates.Creates)
   239  
   240  	opts := *auth
   241  	opts.NoSend = true
   242  
   243  	byteCode := hex.DecodeBig(Counter.CounterBin).Bytes()
   244  
   245  	tx, err := sc.OpCreate(&opts, byteCode, big.NewInt(0).SetInt64(int64(len(byteCode))))
   246  	require.NoError(t, err)
   247  
   248  	return tx, nil
   249  }
   250  
   251  func createCreate2SignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   252  	scInterface := customData["sc"]
   253  	sc := scInterface.(*Creates.Creates)
   254  
   255  	opts := *auth
   256  	opts.NoSend = true
   257  
   258  	byteCode := hex.DecodeBig(Counter.CounterBin).Bytes()
   259  
   260  	tx, err := sc.OpCreate2(&opts, byteCode, big.NewInt(0).SetInt64(int64(len(byteCode))))
   261  	require.NoError(t, err)
   262  
   263  	return tx, nil
   264  }
   265  
   266  func prepareCalls(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client) (map[string]interface{}, error) {
   267  	scAddr, tx, _, err := Called.DeployCalled(auth, client)
   268  	require.NoError(t, err)
   269  
   270  	err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   271  	require.NoError(t, err)
   272  
   273  	_, tx, sc, err := Caller.DeployCaller(auth, client)
   274  	require.NoError(t, err)
   275  
   276  	err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   277  	require.NoError(t, err)
   278  
   279  	return map[string]interface{}{
   280  		"sc":            sc,
   281  		"calledAddress": scAddr,
   282  	}, nil
   283  }
   284  
   285  func createCallSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   286  	scInterface := customData["sc"]
   287  	sc := scInterface.(*Caller.Caller)
   288  
   289  	calledAddressInterface := customData["calledAddress"]
   290  	calledAddress := calledAddressInterface.(common.Address)
   291  
   292  	opts := *auth
   293  	opts.NoSend = true
   294  	opts.Value = big.NewInt(2509)
   295  
   296  	gasPrice, err := client.SuggestGasPrice(ctx)
   297  	require.NoError(t, err)
   298  
   299  	opts.GasPrice = gasPrice
   300  	opts.GasLimit = uint64(300000)
   301  
   302  	tx, err := sc.Call(&opts, calledAddress, big.NewInt(1984))
   303  	require.NoError(t, err)
   304  
   305  	return tx, nil
   306  }
   307  
   308  func createDelegateCallSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   309  	scInterface := customData["sc"]
   310  	sc := scInterface.(*Caller.Caller)
   311  
   312  	calledAddressInterface := customData["calledAddress"]
   313  	calledAddress := calledAddressInterface.(common.Address)
   314  
   315  	opts := *auth
   316  	opts.NoSend = true
   317  	opts.Value = big.NewInt(2509)
   318  
   319  	gasPrice, err := client.SuggestGasPrice(ctx)
   320  	require.NoError(t, err)
   321  
   322  	opts.GasPrice = gasPrice
   323  	opts.GasLimit = uint64(300000)
   324  
   325  	tx, err := sc.DelegateCall(&opts, calledAddress, big.NewInt(1984))
   326  	require.NoError(t, err)
   327  
   328  	return tx, nil
   329  }
   330  
   331  func createMultiCallSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   332  	scInterface := customData["sc"]
   333  	sc := scInterface.(*Caller.Caller)
   334  
   335  	calledAddressInterface := customData["calledAddress"]
   336  	calledAddress := calledAddressInterface.(common.Address)
   337  
   338  	opts := *auth
   339  	opts.NoSend = true
   340  	opts.Value = big.NewInt(2509)
   341  
   342  	gasPrice, err := client.SuggestGasPrice(ctx)
   343  	require.NoError(t, err)
   344  
   345  	opts.GasPrice = gasPrice
   346  	opts.GasLimit = uint64(300000)
   347  
   348  	tx, err := sc.MultiCall(&opts, calledAddress, big.NewInt(1984))
   349  	require.NoError(t, err)
   350  
   351  	return tx, nil
   352  }
   353  
   354  func createInvalidStaticCallLessParametersSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   355  	scInterface := customData["sc"]
   356  	sc := scInterface.(*Caller.Caller)
   357  
   358  	calledAddressInterface := customData["calledAddress"]
   359  	calledAddress := calledAddressInterface.(common.Address)
   360  
   361  	opts := *auth
   362  	opts.NoSend = true
   363  	opts.Value = big.NewInt(2509)
   364  
   365  	gasPrice, err := client.SuggestGasPrice(ctx)
   366  	require.NoError(t, err)
   367  
   368  	opts.GasPrice = gasPrice
   369  	opts.GasLimit = uint64(300000)
   370  
   371  	tx, err := sc.InvalidStaticCallLessParameters(&opts, calledAddress)
   372  	require.NoError(t, err)
   373  
   374  	return tx, nil
   375  }
   376  
   377  func createInvalidStaticCallMoreParametersSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   378  	scInterface := customData["sc"]
   379  	sc := scInterface.(*Caller.Caller)
   380  
   381  	calledAddressInterface := customData["calledAddress"]
   382  	calledAddress := calledAddressInterface.(common.Address)
   383  
   384  	opts := *auth
   385  	opts.NoSend = true
   386  	opts.Value = big.NewInt(2509)
   387  
   388  	gasPrice, err := client.SuggestGasPrice(ctx)
   389  	require.NoError(t, err)
   390  
   391  	opts.GasPrice = gasPrice
   392  	opts.GasLimit = uint64(300000)
   393  
   394  	tx, err := sc.InvalidStaticCallMoreParameters(&opts, calledAddress)
   395  	require.NoError(t, err)
   396  
   397  	return tx, nil
   398  }
   399  
   400  func createInvalidStaticCallWithInnerCallSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   401  	scInterface := customData["sc"]
   402  	sc := scInterface.(*Caller.Caller)
   403  
   404  	calledAddressInterface := customData["calledAddress"]
   405  	calledAddress := calledAddressInterface.(common.Address)
   406  
   407  	opts := *auth
   408  	opts.NoSend = true
   409  	opts.Value = big.NewInt(2509)
   410  
   411  	gasPrice, err := client.SuggestGasPrice(ctx)
   412  	require.NoError(t, err)
   413  
   414  	opts.GasPrice = gasPrice
   415  	opts.GasLimit = uint64(300000)
   416  
   417  	tx, err := sc.InvalidStaticCallWithInnerCall(&opts, calledAddress)
   418  	require.NoError(t, err)
   419  
   420  	return tx, nil
   421  }
   422  
   423  func createPreEcrecover0SignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   424  	scInterface := customData["sc"]
   425  	sc := scInterface.(*Caller.Caller)
   426  
   427  	opts := *auth
   428  	opts.NoSend = true
   429  
   430  	gasPrice, err := client.SuggestGasPrice(ctx)
   431  	require.NoError(t, err)
   432  
   433  	opts.GasPrice = gasPrice
   434  	opts.GasLimit = uint64(300000)
   435  
   436  	tx, err := sc.PreEcrecover0(&opts)
   437  	require.NoError(t, err)
   438  
   439  	return tx, nil
   440  }
   441  
   442  func prepareChainCalls(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client) (map[string]interface{}, error) {
   443  	scAddrLevel4, tx, _, err := ChainCallLevel4.DeployChainCallLevel4(auth, client)
   444  	require.NoError(t, err)
   445  
   446  	err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   447  	require.NoError(t, err)
   448  
   449  	scAddrLevel3, tx, _, err := ChainCallLevel3.DeployChainCallLevel3(auth, client)
   450  	require.NoError(t, err)
   451  
   452  	err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   453  	require.NoError(t, err)
   454  
   455  	scAddrLevel2, tx, _, err := ChainCallLevel2.DeployChainCallLevel2(auth, client)
   456  	require.NoError(t, err)
   457  
   458  	err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   459  	require.NoError(t, err)
   460  
   461  	_, tx, sc, err := ChainCallLevel1.DeployChainCallLevel1(auth, client)
   462  	require.NoError(t, err)
   463  
   464  	err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   465  	require.NoError(t, err)
   466  
   467  	return map[string]interface{}{
   468  		"sc":            sc,
   469  		"level2Address": scAddrLevel2,
   470  		"level3Address": scAddrLevel3,
   471  		"level4Address": scAddrLevel4,
   472  	}, nil
   473  }
   474  
   475  func createChainCallSignedTx(t *testing.T, ctx context.Context, auth *bind.TransactOpts, client *ethclient.Client, customData map[string]interface{}) (*ethTypes.Transaction, error) {
   476  	scInterface := customData["sc"]
   477  	sc := scInterface.(*ChainCallLevel1.ChainCallLevel1)
   478  
   479  	level2AddressInterface := customData["level2Address"]
   480  	level2Address := level2AddressInterface.(common.Address)
   481  
   482  	level3AddressInterface := customData["level3Address"]
   483  	level3Address := level3AddressInterface.(common.Address)
   484  
   485  	level4AddressInterface := customData["level4Address"]
   486  	level4Address := level4AddressInterface.(common.Address)
   487  
   488  	opts := *auth
   489  	opts.NoSend = true
   490  	opts.Value = big.NewInt(2509)
   491  
   492  	gasPrice, err := client.SuggestGasPrice(ctx)
   493  	require.NoError(t, err)
   494  
   495  	opts.GasPrice = gasPrice
   496  	opts.GasLimit = uint64(300000)
   497  
   498  	tx, err := sc.Exec(&opts, level2Address, level3Address, level4Address)
   499  	require.NoError(t, err)
   500  
   501  	return tx, nil
   502  }
   503  
   504  func saveTraceResultToFile(t *testing.T, name, network string, signedTx *ethTypes.Transaction, trace json.RawMessage, skip bool) {
   505  	if skip {
   506  		return
   507  	}
   508  	const path = "/Users/thiago/github.com/0xPolygon/supernets2-node/dist/%v.json"
   509  	sanitizedNetworkName := strings.ReplaceAll(name+network+"_", " ", "_")
   510  	filePath := fmt.Sprintf(path, sanitizedNetworkName)
   511  	b, _ := signedTx.MarshalBinary()
   512  	fileContent := struct {
   513  		Tx    *ethTypes.Transaction
   514  		RLP   string
   515  		Trace json.RawMessage
   516  	}{
   517  		Tx:    signedTx,
   518  		RLP:   hex.EncodeToHex(b),
   519  		Trace: trace,
   520  	}
   521  	c, err := json.MarshalIndent(fileContent, "", "    ")
   522  	require.NoError(t, err)
   523  	err = os.WriteFile(filePath, c, 0644)
   524  	require.NoError(t, err)
   525  }