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

     1  package e2e
     2  
     3  import (
     4  	"context"
     5  	"math/big"
     6  	"testing"
     7  
     8  	"github.com/0xPolygon/supernets2-node/log"
     9  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/Counter"
    10  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/EmitLog2"
    11  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/FailureTest"
    12  	"github.com/0xPolygon/supernets2-node/test/contracts/bin/Read"
    13  	"github.com/0xPolygon/supernets2-node/test/operations"
    14  	"github.com/ethereum/go-ethereum"
    15  	"github.com/ethereum/go-ethereum/accounts/abi/bind"
    16  	"github.com/ethereum/go-ethereum/common"
    17  	"github.com/stretchr/testify/assert"
    18  	"github.com/stretchr/testify/require"
    19  )
    20  
    21  func TestCounter(t *testing.T) {
    22  	if testing.Short() {
    23  		t.Skip()
    24  	}
    25  
    26  	var err error
    27  	err = operations.Teardown()
    28  	require.NoError(t, err)
    29  
    30  	defer func() { require.NoError(t, operations.Teardown()) }()
    31  
    32  	ctx := context.Background()
    33  	opsCfg := operations.GetDefaultOperationsConfig()
    34  	opsMan, err := operations.NewManager(ctx, opsCfg)
    35  	require.NoError(t, err)
    36  	err = opsMan.Setup()
    37  	require.NoError(t, err)
    38  
    39  	for _, network := range networks {
    40  		log.Debugf(network.Name)
    41  		client := operations.MustGetClient(network.URL)
    42  		auth := operations.MustGetAuth(network.PrivateKey, network.ChainID)
    43  
    44  		_, scTx, sc, err := Counter.DeployCounter(auth, client)
    45  		require.NoError(t, err)
    46  
    47  		logTx(scTx)
    48  		err = operations.WaitTxToBeMined(ctx, client, scTx, operations.DefaultTimeoutTxToBeMined)
    49  		require.NoError(t, err)
    50  
    51  		count, err := sc.GetCount(&bind.CallOpts{Pending: false})
    52  		require.NoError(t, err)
    53  
    54  		assert.Equal(t, 0, count.Cmp(big.NewInt(0)))
    55  
    56  		scCallTx, err := sc.Increment(auth)
    57  		require.NoError(t, err)
    58  
    59  		logTx(scCallTx)
    60  		err = operations.WaitTxToBeMined(ctx, client, scCallTx, operations.DefaultTimeoutTxToBeMined)
    61  		require.NoError(t, err)
    62  
    63  		count, err = sc.GetCount(&bind.CallOpts{Pending: false})
    64  		require.NoError(t, err)
    65  		assert.Equal(t, 0, count.Cmp(big.NewInt(1)))
    66  	}
    67  }
    68  
    69  func TestEmitLog2(t *testing.T) {
    70  	if testing.Short() {
    71  		t.Skip()
    72  	}
    73  
    74  	var err error
    75  	err = operations.Teardown()
    76  	require.NoError(t, err)
    77  
    78  	defer func() { require.NoError(t, operations.Teardown()) }()
    79  
    80  	ctx := context.Background()
    81  	opsCfg := operations.GetDefaultOperationsConfig()
    82  	opsMan, err := operations.NewManager(ctx, opsCfg)
    83  	require.NoError(t, err)
    84  	err = opsMan.Setup()
    85  	require.NoError(t, err)
    86  
    87  	for _, network := range networks {
    88  		log.Debugf(network.Name)
    89  		client := operations.MustGetClient(network.URL)
    90  		auth := operations.MustGetAuth(network.PrivateKey, network.ChainID)
    91  
    92  		scAddr, scTx, sc, err := EmitLog2.DeployEmitLog2(auth, client)
    93  		require.NoError(t, err)
    94  
    95  		logTx(scTx)
    96  		err = operations.WaitTxToBeMined(ctx, client, scTx, operations.DefaultTimeoutTxToBeMined)
    97  		require.NoError(t, err)
    98  
    99  		scCallTx, err := sc.EmitLogs(auth)
   100  		require.NoError(t, err)
   101  
   102  		logTx(scCallTx)
   103  		err = operations.WaitTxToBeMined(ctx, client, scCallTx, operations.DefaultTimeoutTxToBeMined)
   104  		require.NoError(t, err)
   105  
   106  		scCallTxReceipt, err := client.TransactionReceipt(ctx, scCallTx.Hash())
   107  		require.NoError(t, err)
   108  
   109  		filterBlock := scCallTxReceipt.BlockNumber
   110  		logs, err := client.FilterLogs(ctx, ethereum.FilterQuery{
   111  			FromBlock: filterBlock, ToBlock: filterBlock,
   112  			Addresses: []common.Address{scAddr},
   113  		})
   114  		require.NoError(t, err)
   115  		assert.Equal(t, 4, len(logs))
   116  
   117  		log0 := logs[0]
   118  		assert.Equal(t, 0, len(log0.Topics))
   119  
   120  		_, err = sc.ParseLog(logs[1])
   121  		require.NoError(t, err)
   122  
   123  		logA, err := sc.ParseLogA(logs[2])
   124  		require.NoError(t, err)
   125  		assert.Equal(t, big.NewInt(1), logA.A)
   126  
   127  		logABCD, err := sc.ParseLogABCD(logs[3])
   128  		require.NoError(t, err)
   129  		assert.Equal(t, big.NewInt(1), logABCD.A)
   130  		assert.Equal(t, big.NewInt(2), logABCD.B)
   131  		assert.Equal(t, big.NewInt(3), logABCD.C)
   132  		assert.Equal(t, big.NewInt(4), logABCD.D)
   133  	}
   134  }
   135  
   136  func TestFailureTest(t *testing.T) {
   137  	if testing.Short() {
   138  		t.Skip()
   139  	}
   140  
   141  	var err error
   142  	err = operations.Teardown()
   143  	require.NoError(t, err)
   144  
   145  	defer func() { require.NoError(t, operations.Teardown()) }()
   146  
   147  	ctx := context.Background()
   148  	opsCfg := operations.GetDefaultOperationsConfig()
   149  	opsMan, err := operations.NewManager(ctx, opsCfg)
   150  	require.NoError(t, err)
   151  	err = opsMan.Setup()
   152  	require.NoError(t, err)
   153  
   154  	for _, network := range networks {
   155  		log.Debugf(network.Name)
   156  		client := operations.MustGetClient(network.URL)
   157  		auth := operations.MustGetAuth(network.PrivateKey, network.ChainID)
   158  
   159  		log.Debug("deploying SC")
   160  		_, scTx, sc, err := FailureTest.DeployFailureTest(auth, client)
   161  		require.NoError(t, err)
   162  
   163  		logTx(scTx)
   164  		err = operations.WaitTxToBeMined(ctx, client, scTx, operations.DefaultTimeoutTxToBeMined)
   165  		require.NoError(t, err)
   166  
   167  		log.Debug("storing value")
   168  		scCallTx, err := sc.Store(auth, big.NewInt(1))
   169  		require.NoError(t, err)
   170  
   171  		logTx(scCallTx)
   172  		err = operations.WaitTxToBeMined(ctx, client, scCallTx, operations.DefaultTimeoutTxToBeMined)
   173  		require.NoError(t, err)
   174  
   175  		log.Debug("storing value with revert")
   176  		_, err = sc.StoreAndFail(auth, big.NewInt(2))
   177  		assert.Equal(t, "execution reverted: this method always fails", err.Error())
   178  	}
   179  }
   180  
   181  func TestRead(t *testing.T) {
   182  	if testing.Short() {
   183  		t.Skip()
   184  	}
   185  
   186  	var err error
   187  	err = operations.Teardown()
   188  	require.NoError(t, err)
   189  
   190  	defer func() { require.NoError(t, operations.Teardown()) }()
   191  
   192  	ctx := context.Background()
   193  	opsCfg := operations.GetDefaultOperationsConfig()
   194  	opsMan, err := operations.NewManager(ctx, opsCfg)
   195  	require.NoError(t, err)
   196  	err = opsMan.Setup()
   197  	require.NoError(t, err)
   198  
   199  	for _, network := range networks {
   200  		log.Debugf(network.Name)
   201  		client := operations.MustGetClient(network.URL)
   202  		auth := operations.MustGetAuth(network.PrivateKey, network.ChainID)
   203  
   204  		const ownerName = "this is the owner name"
   205  		callOpts := &bind.CallOpts{Pending: false}
   206  
   207  		log.Debug("deploying SC")
   208  		_, scTx, sc, err := Read.DeployRead(auth, client, ownerName)
   209  		require.NoError(t, err)
   210  
   211  		logTx(scTx)
   212  		err = operations.WaitTxToBeMined(ctx, client, scTx, operations.DefaultTimeoutTxToBeMined)
   213  		require.NoError(t, err)
   214  
   215  		log.Debug("read string public variable directly")
   216  		ownerNameValue, err := sc.OwnerName(callOpts)
   217  		require.NoError(t, err)
   218  		require.Equal(t, ownerName, ownerNameValue)
   219  
   220  		log.Debug("read address public variable directly")
   221  		ownerValue, err := sc.Owner(callOpts)
   222  		require.NoError(t, err)
   223  		require.Equal(t, auth.From, ownerValue)
   224  
   225  		tA := Read.Readtoken{
   226  			Name:     "Token A",
   227  			Quantity: big.NewInt(50),
   228  			Address:  common.HexToAddress("0x1"),
   229  		}
   230  
   231  		tB := Read.Readtoken{
   232  			Name:     "Token B",
   233  			Quantity: big.NewInt(30),
   234  			Address:  common.HexToAddress("0x2"),
   235  		}
   236  
   237  		log.Debug("public add token")
   238  		tx, err := sc.PublicAddToken(auth, tA)
   239  		require.NoError(t, err)
   240  		logTx(tx)
   241  		err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   242  		require.NoError(t, err)
   243  
   244  		log.Debug("external add token")
   245  		tx, err = sc.ExternalAddToken(auth, tB)
   246  		require.NoError(t, err)
   247  		logTx(tx)
   248  		err = operations.WaitTxToBeMined(ctx, client, tx, operations.DefaultTimeoutTxToBeMined)
   249  		require.NoError(t, err)
   250  
   251  		log.Debug("read mapping public variable directly")
   252  		tk, err := sc.Tokens(callOpts, tA.Address)
   253  		require.NoError(t, err)
   254  		require.Equal(t, tA.Name, tk.Name)
   255  		require.Equal(t, tA.Quantity, tk.Quantity)
   256  		require.Equal(t, tA.Address, tk.Address)
   257  
   258  		tk, err = sc.Tokens(callOpts, tB.Address)
   259  		require.NoError(t, err)
   260  		require.Equal(t, tB.Name, tk.Name)
   261  		require.Equal(t, tB.Quantity, tk.Quantity)
   262  		require.Equal(t, tB.Address, tk.Address)
   263  
   264  		log.Debug("public struct read")
   265  		tk, err = sc.PublicGetToken(callOpts, tA.Address)
   266  		require.NoError(t, err)
   267  		require.Equal(t, tA.Name, tk.Name)
   268  		require.Equal(t, tA.Quantity, tk.Quantity)
   269  		require.Equal(t, tA.Address, tk.Address)
   270  
   271  		log.Debug("external struct read")
   272  		tk, err = sc.ExternalGetToken(callOpts, tB.Address)
   273  		require.NoError(t, err)
   274  		require.Equal(t, tB.Name, tk.Name)
   275  		require.Equal(t, tB.Quantity, tk.Quantity)
   276  		require.Equal(t, tB.Address, tk.Address)
   277  
   278  		log.Debug("public uint256 read")
   279  		value, err := sc.PublicRead(callOpts)
   280  		require.NoError(t, err)
   281  		require.Equal(t, 0, big.NewInt(1).Cmp(value))
   282  
   283  		log.Debug("external uint256 read")
   284  		value, err = sc.ExternalRead(callOpts)
   285  		require.NoError(t, err)
   286  		require.Equal(t, 0, big.NewInt(1).Cmp(value))
   287  
   288  		log.Debug("public uint256 read with parameter")
   289  		value, err = sc.PublicReadWParams(callOpts, big.NewInt(1))
   290  		require.NoError(t, err)
   291  		require.Equal(t, 0, big.NewInt(2).Cmp(value))
   292  
   293  		log.Debug("external uint256 read with parameter")
   294  		value, err = sc.ExternalReadWParams(callOpts, big.NewInt(1))
   295  		require.NoError(t, err)
   296  		require.Equal(t, 0, big.NewInt(2).Cmp(value))
   297  	}
   298  }