github.com/hyperledger/burrow@v0.34.5-0.20220512172541-77f09336001d/execution/wasm/wasm_test.go (about)

     1  package wasm
     2  
     3  import (
     4  	"encoding/hex"
     5  	"fmt"
     6  	"math/big"
     7  	"testing"
     8  
     9  	"github.com/hyperledger/burrow/execution/native"
    10  
    11  	"github.com/hyperledger/burrow/execution/exec"
    12  
    13  	"github.com/hyperledger/burrow/acm/acmstate"
    14  	"github.com/hyperledger/burrow/binary"
    15  	"github.com/hyperledger/burrow/execution/engine"
    16  	"github.com/hyperledger/burrow/execution/evm/abi"
    17  
    18  	"github.com/hyperledger/burrow/crypto"
    19  	"github.com/stretchr/testify/require"
    20  )
    21  
    22  func TestStaticCallWithValue(t *testing.T) {
    23  	cache := acmstate.NewMemoryState()
    24  
    25  	params := engine.CallParams{
    26  		Origin: crypto.ZeroAddress,
    27  		Caller: crypto.ZeroAddress,
    28  		Callee: crypto.ZeroAddress,
    29  		Input:  []byte{},
    30  		Value:  *big.NewInt(0),
    31  		Gas:    big.NewInt(1000),
    32  	}
    33  
    34  	vm := Default()
    35  	blockchain := new(engine.TestBlockchain)
    36  	eventSink := exec.NewNoopEventSink()
    37  
    38  	// run constructor
    39  	runtime, cerr := vm.Execute(cache, blockchain, eventSink, params, Bytecode_storage_test)
    40  	require.NoError(t, cerr)
    41  
    42  	// run getFooPlus2
    43  	spec, err := abi.ReadSpec(Abi_storage_test)
    44  	require.NoError(t, err)
    45  	calldata, _, err := spec.Pack("getFooPlus2")
    46  
    47  	params.Input = calldata
    48  
    49  	returndata, cerr := vm.Execute(cache, blockchain, eventSink, params, runtime)
    50  	require.NoError(t, cerr)
    51  
    52  	data := abi.GetPackingTypes(spec.Functions["getFooPlus2"].Outputs)
    53  
    54  	err = spec.Unpack(returndata, "getFooPlus2", data...)
    55  	require.NoError(t, err)
    56  	returnValue := *data[0].(*uint64)
    57  	var expected uint64
    58  	expected = 104
    59  	require.Equal(t, expected, returnValue)
    60  
    61  	// call incFoo
    62  	calldata, _, err = spec.Pack("incFoo")
    63  
    64  	params.Input = calldata
    65  
    66  	returndata, cerr = vm.Execute(cache, blockchain, eventSink, params, runtime)
    67  	require.NoError(t, cerr)
    68  
    69  	require.Equal(t, returndata, []byte{})
    70  
    71  	// run getFooPlus2
    72  	calldata, _, err = spec.Pack("getFooPlus2")
    73  	require.NoError(t, err)
    74  
    75  	params.Input = calldata
    76  
    77  	returndata, cerr = vm.Execute(cache, blockchain, eventSink, params, runtime)
    78  	require.NoError(t, cerr)
    79  
    80  	spec.Unpack(returndata, "getFooPlus2", data...)
    81  	expected = 105
    82  	returnValue = *data[0].(*uint64)
    83  
    84  	require.Equal(t, expected, returnValue)
    85  }
    86  
    87  func TestCREATE(t *testing.T) {
    88  	cache := acmstate.NewMemoryState()
    89  
    90  	params := engine.CallParams{
    91  		Origin: crypto.ZeroAddress,
    92  		Caller: crypto.ZeroAddress,
    93  		Callee: crypto.ZeroAddress,
    94  		Input:  []byte{},
    95  		Value:  *big.NewInt(0),
    96  		Gas:    big.NewInt(1000),
    97  	}
    98  
    99  	vm := New(engine.Options{Natives: native.MustDefaultNatives()})
   100  	blockchain := new(engine.TestBlockchain)
   101  	eventSink := exec.NewNoopEventSink()
   102  
   103  	// run constructor
   104  	runtime, cerr := vm.Execute(cache, blockchain, eventSink, params, CREATETest)
   105  	require.NoError(t, cerr)
   106  
   107  	// run createChild
   108  	spec, err := abi.ReadSpec(Abi_CREATETest)
   109  	require.NoError(t, err)
   110  	calldata, _, err := spec.Pack("createChild")
   111  
   112  	params.Input = calldata
   113  
   114  	_, rerr := vm.Execute(cache, blockchain, eventSink, params, runtime)
   115  	vm.options.Nonce = []byte{0xff}
   116  	_, rerr = vm.Execute(cache, blockchain, eventSink, params, runtime)
   117  	require.NoError(t, rerr)
   118  
   119  	// get created child
   120  	calldata, _, err = spec.Pack("getChild", "0")
   121  	require.NoError(t, err)
   122  
   123  	params.Input = calldata
   124  
   125  	res, rerr := vm.Execute(cache, blockchain, eventSink, params, runtime)
   126  	require.NoError(t, rerr)
   127  	require.Equal(t, "000000000000000000000000ef2fb521372225b89169ba60500142f68ebd82d3", hex.EncodeToString(res))
   128  
   129  	calldata, _, err = spec.Pack("getChild", "1")
   130  	require.NoError(t, err)
   131  
   132  	params.Input = calldata
   133  
   134  	res, rerr = vm.Execute(cache, blockchain, eventSink, params, runtime)
   135  	require.NoError(t, rerr)
   136  	require.Equal(t, "00000000000000000000000089686394a7cf94be0aa48ae593fe3cad5cbdbace", hex.EncodeToString(res))
   137  }
   138  
   139  func TestSelfDestruct(t *testing.T) {
   140  	cache := acmstate.NewMemoryState()
   141  
   142  	params := engine.CallParams{
   143  		Origin: crypto.ZeroAddress,
   144  		Caller: crypto.ZeroAddress,
   145  		Callee: crypto.ZeroAddress,
   146  		Input:  []byte{},
   147  		Value:  *big.NewInt(0),
   148  		Gas:    big.NewInt(1000),
   149  	}
   150  
   151  	vm := New(engine.Options{Natives: native.MustDefaultNatives()})
   152  	blockchain := new(engine.TestBlockchain)
   153  	eventSink := exec.NewNoopEventSink()
   154  
   155  	// run constructor
   156  	runtime, cerr := vm.Execute(cache, blockchain, eventSink, params, CREATETest)
   157  	require.NoError(t, cerr)
   158  	require.Equal(t, 1, len(cache.Accounts))
   159  
   160  	// run selfdestruct
   161  	spec, err := abi.ReadSpec(Abi_CREATETest)
   162  	require.NoError(t, err)
   163  	calldata, _, err := spec.Pack("close")
   164  
   165  	params.Input = calldata
   166  
   167  	_, rerr := vm.Execute(cache, blockchain, eventSink, params, runtime)
   168  	require.NoError(t, rerr)
   169  
   170  	require.Equal(t, 0, len(cache.Accounts))
   171  }
   172  
   173  func TestMisc(t *testing.T) {
   174  	cache := acmstate.NewMemoryState()
   175  
   176  	params := engine.CallParams{
   177  		Origin: crypto.ZeroAddress,
   178  		Caller: crypto.ZeroAddress,
   179  		Callee: crypto.ZeroAddress,
   180  		Input:  []byte{},
   181  		Value:  *big.NewInt(0),
   182  		Gas:    big.NewInt(1000),
   183  	}
   184  
   185  	vm := New(engine.Options{Natives: native.MustDefaultNatives()})
   186  	blockchain := new(engine.TestBlockchain)
   187  	eventSink := exec.NewNoopEventSink()
   188  
   189  	// run constructor
   190  	runtime, cerr := vm.Execute(cache, blockchain, eventSink, params, CREATETest)
   191  	require.NoError(t, cerr)
   192  
   193  	// run txGasPrice
   194  	spec, err := abi.ReadSpec(Abi_CREATETest)
   195  	require.NoError(t, err)
   196  	calldata, _, err := spec.Pack("txPrice")
   197  
   198  	params.Input = calldata
   199  
   200  	res, rerr := vm.Execute(cache, blockchain, eventSink, params, runtime)
   201  	require.NoError(t, rerr)
   202  	require.Equal(t, "0000000000000000000000000000000000000000000000000000000000000001", hex.EncodeToString(res))
   203  
   204  	// run blockDifficulty
   205  	spec, err = abi.ReadSpec(Abi_CREATETest)
   206  	require.NoError(t, err)
   207  	calldata, _, err = spec.Pack("blockDifficulty")
   208  
   209  	params.Input = calldata
   210  
   211  	res, rerr = vm.Execute(cache, blockchain, eventSink, params, runtime)
   212  	require.NoError(t, rerr)
   213  	require.Equal(t, "0000000000000000000000000000000000000000000000000000000000000001", hex.EncodeToString(res))
   214  }
   215  
   216  func blockHashGetter(height uint64) []byte {
   217  	return binary.LeftPadWord256([]byte(fmt.Sprintf("block_hash_%d", height))).Bytes()
   218  }