github.com/codingfuture/orig-energi3@v0.8.4/accounts/abi/event_test.go (about)

     1  // Copyright 2016 The go-ethereum Authors
     2  // This file is part of the go-ethereum library.
     3  //
     4  // The go-ethereum library is free software: you can redistribute it and/or modify
     5  // it under the terms of the GNU Lesser General Public License as published by
     6  // the Free Software Foundation, either version 3 of the License, or
     7  // (at your option) any later version.
     8  //
     9  // The go-ethereum library is distributed in the hope that it will be useful,
    10  // but WITHOUT ANY WARRANTY; without even the implied warranty of
    11  // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
    12  // GNU Lesser General Public License for more details.
    13  //
    14  // You should have received a copy of the GNU Lesser General Public License
    15  // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
    16  
    17  package abi
    18  
    19  import (
    20  	"bytes"
    21  	"encoding/hex"
    22  	"encoding/json"
    23  	"math/big"
    24  	"reflect"
    25  	"strings"
    26  	"testing"
    27  
    28  	"github.com/ethereum/go-ethereum/common"
    29  	"github.com/ethereum/go-ethereum/crypto"
    30  	"github.com/stretchr/testify/assert"
    31  	"github.com/stretchr/testify/require"
    32  )
    33  
    34  var jsonEventTransfer = []byte(`{
    35    "anonymous": false,
    36    "inputs": [
    37      {
    38        "indexed": true, "name": "from", "type": "address"
    39      }, {
    40        "indexed": true, "name": "to", "type": "address"
    41      }, {
    42        "indexed": false, "name": "value", "type": "uint256"
    43    }],
    44    "name": "Transfer",
    45    "type": "event"
    46  }`)
    47  
    48  var jsonEventPledge = []byte(`{
    49    "anonymous": false,
    50    "inputs": [{
    51        "indexed": false, "name": "who", "type": "address"
    52      }, {
    53        "indexed": false, "name": "wad", "type": "uint128"
    54      }, {
    55        "indexed": false, "name": "currency", "type": "bytes3"
    56    }],
    57    "name": "Pledge",
    58    "type": "event"
    59  }`)
    60  
    61  var jsonEventMixedCase = []byte(`{
    62  	"anonymous": false,
    63  	"inputs": [{
    64  		"indexed": false, "name": "value", "type": "uint256"
    65  	  }, {
    66  		"indexed": false, "name": "_value", "type": "uint256"
    67  	  }, {
    68  		"indexed": false, "name": "Value", "type": "uint256"
    69  	}],
    70  	"name": "MixedCase",
    71  	"type": "event"
    72    }`)
    73  
    74  // 1000000
    75  var transferData1 = "00000000000000000000000000000000000000000000000000000000000f4240"
    76  
    77  // "0x00Ce0d46d924CC8437c806721496599FC3FFA268", 2218516807680, "usd"
    78  var pledgeData1 = "00000000000000000000000000ce0d46d924cc8437c806721496599fc3ffa2680000000000000000000000000000000000000000000000000000020489e800007573640000000000000000000000000000000000000000000000000000000000"
    79  
    80  // 1000000,2218516807680,1000001
    81  var mixedCaseData1 = "00000000000000000000000000000000000000000000000000000000000f42400000000000000000000000000000000000000000000000000000020489e8000000000000000000000000000000000000000000000000000000000000000f4241"
    82  
    83  func TestEventId(t *testing.T) {
    84  	var table = []struct {
    85  		definition   string
    86  		expectations map[string]common.Hash
    87  	}{
    88  		{
    89  			definition: `[
    90  			{ "type" : "event", "name" : "Balance", "inputs": [{ "name" : "in", "type": "uint256" }] },
    91  			{ "type" : "event", "name" : "Check", "inputs": [{ "name" : "t", "type": "address" }, { "name": "b", "type": "uint256" }] }
    92  			]`,
    93  			expectations: map[string]common.Hash{
    94  				"Balance": crypto.Keccak256Hash([]byte("Balance(uint256)")),
    95  				"Check":   crypto.Keccak256Hash([]byte("Check(address,uint256)")),
    96  			},
    97  		},
    98  	}
    99  
   100  	for _, test := range table {
   101  		abi, err := JSON(strings.NewReader(test.definition))
   102  		if err != nil {
   103  			t.Fatal(err)
   104  		}
   105  
   106  		for name, event := range abi.Events {
   107  			if event.Id() != test.expectations[name] {
   108  				t.Errorf("expected id to be %x, got %x", test.expectations[name], event.Id())
   109  			}
   110  		}
   111  	}
   112  }
   113  
   114  func TestEventString(t *testing.T) {
   115  	var table = []struct {
   116  		definition   string
   117  		expectations map[string]string
   118  	}{
   119  		{
   120  			definition: `[
   121  			{ "type" : "event", "name" : "Balance", "inputs": [{ "name" : "in", "type": "uint256" }] },
   122  			{ "type" : "event", "name" : "Check", "inputs": [{ "name" : "t", "type": "address" }, { "name": "b", "type": "uint256" }] },
   123  			{ "type" : "event", "name" : "Transfer", "inputs": [{ "name": "from", "type": "address", "indexed": true }, { "name": "to", "type": "address", "indexed": true }, { "name": "value", "type": "uint256" }] }
   124  			]`,
   125  			expectations: map[string]string{
   126  				"Balance":  "event Balance(uint256 in)",
   127  				"Check":    "event Check(address t, uint256 b)",
   128  				"Transfer": "event Transfer(address indexed from, address indexed to, uint256 value)",
   129  			},
   130  		},
   131  	}
   132  
   133  	for _, test := range table {
   134  		abi, err := JSON(strings.NewReader(test.definition))
   135  		if err != nil {
   136  			t.Fatal(err)
   137  		}
   138  
   139  		for name, event := range abi.Events {
   140  			if event.String() != test.expectations[name] {
   141  				t.Errorf("expected string to be %s, got %s", test.expectations[name], event.String())
   142  			}
   143  		}
   144  	}
   145  }
   146  
   147  // TestEventMultiValueWithArrayUnpack verifies that array fields will be counted after parsing array.
   148  func TestEventMultiValueWithArrayUnpack(t *testing.T) {
   149  	definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": false, "name":"value1", "type":"uint8[2]"},{"indexed": false, "name":"value2", "type":"uint8"}]}]`
   150  	type testStruct struct {
   151  		Value1 [2]uint8
   152  		Value2 uint8
   153  	}
   154  	abi, err := JSON(strings.NewReader(definition))
   155  	require.NoError(t, err)
   156  	var b bytes.Buffer
   157  	var i uint8 = 1
   158  	for ; i <= 3; i++ {
   159  		b.Write(packNum(reflect.ValueOf(i)))
   160  	}
   161  	var rst testStruct
   162  	require.NoError(t, abi.Unpack(&rst, "test", b.Bytes()))
   163  	require.Equal(t, [2]uint8{1, 2}, rst.Value1)
   164  	require.Equal(t, uint8(3), rst.Value2)
   165  }
   166  
   167  func TestEventTupleUnpack(t *testing.T) {
   168  
   169  	type EventTransfer struct {
   170  		Value *big.Int
   171  	}
   172  
   173  	type EventTransferWithTag struct {
   174  		// this is valid because `value` is not exportable,
   175  		// so value is only unmarshalled into `Value1`.
   176  		value  *big.Int
   177  		Value1 *big.Int `abi:"value"`
   178  	}
   179  
   180  	type BadEventTransferWithSameFieldAndTag struct {
   181  		Value  *big.Int
   182  		Value1 *big.Int `abi:"value"`
   183  	}
   184  
   185  	type BadEventTransferWithDuplicatedTag struct {
   186  		Value1 *big.Int `abi:"value"`
   187  		Value2 *big.Int `abi:"value"`
   188  	}
   189  
   190  	type BadEventTransferWithEmptyTag struct {
   191  		Value *big.Int `abi:""`
   192  	}
   193  
   194  	type EventPledge struct {
   195  		Who      common.Address
   196  		Wad      *big.Int
   197  		Currency [3]byte
   198  	}
   199  
   200  	type BadEventPledge struct {
   201  		Who      string
   202  		Wad      int
   203  		Currency [3]byte
   204  	}
   205  
   206  	type EventMixedCase struct {
   207  		Value1 *big.Int `abi:"value"`
   208  		Value2 *big.Int `abi:"_value"`
   209  		Value3 *big.Int `abi:"Value"`
   210  	}
   211  
   212  	bigint := new(big.Int)
   213  	bigintExpected := big.NewInt(1000000)
   214  	bigintExpected2 := big.NewInt(2218516807680)
   215  	bigintExpected3 := big.NewInt(1000001)
   216  	addr := common.HexToAddress("0x00Ce0d46d924CC8437c806721496599FC3FFA268")
   217  	var testCases = []struct {
   218  		data     string
   219  		dest     interface{}
   220  		expected interface{}
   221  		jsonLog  []byte
   222  		error    string
   223  		name     string
   224  	}{{
   225  		transferData1,
   226  		&EventTransfer{},
   227  		&EventTransfer{Value: bigintExpected},
   228  		jsonEventTransfer,
   229  		"",
   230  		"Can unpack ERC20 Transfer event into structure",
   231  	}, {
   232  		transferData1,
   233  		&[]interface{}{&bigint},
   234  		&[]interface{}{&bigintExpected},
   235  		jsonEventTransfer,
   236  		"",
   237  		"Can unpack ERC20 Transfer event into slice",
   238  	}, {
   239  		transferData1,
   240  		&EventTransferWithTag{},
   241  		&EventTransferWithTag{Value1: bigintExpected},
   242  		jsonEventTransfer,
   243  		"",
   244  		"Can unpack ERC20 Transfer event into structure with abi: tag",
   245  	}, {
   246  		transferData1,
   247  		&BadEventTransferWithDuplicatedTag{},
   248  		&BadEventTransferWithDuplicatedTag{},
   249  		jsonEventTransfer,
   250  		"struct: abi tag in 'Value2' already mapped",
   251  		"Can not unpack ERC20 Transfer event with duplicated abi tag",
   252  	}, {
   253  		transferData1,
   254  		&BadEventTransferWithSameFieldAndTag{},
   255  		&BadEventTransferWithSameFieldAndTag{},
   256  		jsonEventTransfer,
   257  		"abi: multiple variables maps to the same abi field 'value'",
   258  		"Can not unpack ERC20 Transfer event with a field and a tag mapping to the same abi variable",
   259  	}, {
   260  		transferData1,
   261  		&BadEventTransferWithEmptyTag{},
   262  		&BadEventTransferWithEmptyTag{},
   263  		jsonEventTransfer,
   264  		"struct: abi tag in 'Value' is empty",
   265  		"Can not unpack ERC20 Transfer event with an empty tag",
   266  	}, {
   267  		pledgeData1,
   268  		&EventPledge{},
   269  		&EventPledge{
   270  			addr,
   271  			bigintExpected2,
   272  			[3]byte{'u', 's', 'd'}},
   273  		jsonEventPledge,
   274  		"",
   275  		"Can unpack Pledge event into structure",
   276  	}, {
   277  		pledgeData1,
   278  		&[]interface{}{&common.Address{}, &bigint, &[3]byte{}},
   279  		&[]interface{}{
   280  			&addr,
   281  			&bigintExpected2,
   282  			&[3]byte{'u', 's', 'd'}},
   283  		jsonEventPledge,
   284  		"",
   285  		"Can unpack Pledge event into slice",
   286  	}, {
   287  		pledgeData1,
   288  		&[3]interface{}{&common.Address{}, &bigint, &[3]byte{}},
   289  		&[3]interface{}{
   290  			&addr,
   291  			&bigintExpected2,
   292  			&[3]byte{'u', 's', 'd'}},
   293  		jsonEventPledge,
   294  		"",
   295  		"Can unpack Pledge event into an array",
   296  	}, {
   297  		pledgeData1,
   298  		&[]interface{}{new(int), 0, 0},
   299  		&[]interface{}{},
   300  		jsonEventPledge,
   301  		"abi: cannot unmarshal common.Address in to int",
   302  		"Can not unpack Pledge event into slice with wrong types",
   303  	}, {
   304  		pledgeData1,
   305  		&BadEventPledge{},
   306  		&BadEventPledge{},
   307  		jsonEventPledge,
   308  		"abi: cannot unmarshal common.Address in to string",
   309  		"Can not unpack Pledge event into struct with wrong filed types",
   310  	}, {
   311  		pledgeData1,
   312  		&[]interface{}{common.Address{}, new(big.Int)},
   313  		&[]interface{}{},
   314  		jsonEventPledge,
   315  		"abi: insufficient number of elements in the list/array for unpack, want 3, got 2",
   316  		"Can not unpack Pledge event into too short slice",
   317  	}, {
   318  		pledgeData1,
   319  		new(map[string]interface{}),
   320  		&[]interface{}{},
   321  		jsonEventPledge,
   322  		"abi: cannot unmarshal tuple into map[string]interface {}",
   323  		"Can not unpack Pledge event into map",
   324  	}, {
   325  		mixedCaseData1,
   326  		&EventMixedCase{},
   327  		&EventMixedCase{Value1: bigintExpected, Value2: bigintExpected2, Value3: bigintExpected3},
   328  		jsonEventMixedCase,
   329  		"",
   330  		"Can unpack abi variables with mixed case",
   331  	}}
   332  
   333  	for _, tc := range testCases {
   334  		assert := assert.New(t)
   335  		tc := tc
   336  		t.Run(tc.name, func(t *testing.T) {
   337  			err := unpackTestEventData(tc.dest, tc.data, tc.jsonLog, assert)
   338  			if tc.error == "" {
   339  				assert.Nil(err, "Should be able to unpack event data.")
   340  				assert.Equal(tc.expected, tc.dest, tc.name)
   341  			} else {
   342  				assert.EqualError(err, tc.error, tc.name)
   343  			}
   344  		})
   345  	}
   346  }
   347  
   348  func unpackTestEventData(dest interface{}, hexData string, jsonEvent []byte, assert *assert.Assertions) error {
   349  	data, err := hex.DecodeString(hexData)
   350  	assert.NoError(err, "Hex data should be a correct hex-string")
   351  	var e Event
   352  	assert.NoError(json.Unmarshal(jsonEvent, &e), "Should be able to unmarshal event ABI")
   353  	a := ABI{Events: map[string]Event{"e": e}}
   354  	return a.Unpack(dest, "e", data)
   355  }
   356  
   357  /*
   358  Taken from
   359  https://github.com/ethereum/go-ethereum/pull/15568
   360  */
   361  
   362  type testResult struct {
   363  	Values [2]*big.Int
   364  	Value1 *big.Int
   365  	Value2 *big.Int
   366  }
   367  
   368  type testCase struct {
   369  	definition string
   370  	want       testResult
   371  }
   372  
   373  func (tc testCase) encoded(intType, arrayType Type) []byte {
   374  	var b bytes.Buffer
   375  	if tc.want.Value1 != nil {
   376  		val, _ := intType.pack(reflect.ValueOf(tc.want.Value1))
   377  		b.Write(val)
   378  	}
   379  
   380  	if !reflect.DeepEqual(tc.want.Values, [2]*big.Int{nil, nil}) {
   381  		val, _ := arrayType.pack(reflect.ValueOf(tc.want.Values))
   382  		b.Write(val)
   383  	}
   384  	if tc.want.Value2 != nil {
   385  		val, _ := intType.pack(reflect.ValueOf(tc.want.Value2))
   386  		b.Write(val)
   387  	}
   388  	return b.Bytes()
   389  }
   390  
   391  // TestEventUnpackIndexed verifies that indexed field will be skipped by event decoder.
   392  func TestEventUnpackIndexed(t *testing.T) {
   393  	definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": true, "name":"value1", "type":"uint8"},{"indexed": false, "name":"value2", "type":"uint8"}]}]`
   394  	type testStruct struct {
   395  		Value1 uint8
   396  		Value2 uint8
   397  	}
   398  	abi, err := JSON(strings.NewReader(definition))
   399  	require.NoError(t, err)
   400  	var b bytes.Buffer
   401  	b.Write(packNum(reflect.ValueOf(uint8(8))))
   402  	var rst testStruct
   403  	require.NoError(t, abi.Unpack(&rst, "test", b.Bytes()))
   404  	require.Equal(t, uint8(0), rst.Value1)
   405  	require.Equal(t, uint8(8), rst.Value2)
   406  }
   407  
   408  // TestEventIndexedWithArrayUnpack verifies that decoder will not overlow when static array is indexed input.
   409  func TestEventIndexedWithArrayUnpack(t *testing.T) {
   410  	definition := `[{"name": "test", "type": "event", "inputs": [{"indexed": true, "name":"value1", "type":"uint8[2]"},{"indexed": false, "name":"value2", "type":"string"}]}]`
   411  	type testStruct struct {
   412  		Value1 [2]uint8
   413  		Value2 string
   414  	}
   415  	abi, err := JSON(strings.NewReader(definition))
   416  	require.NoError(t, err)
   417  	var b bytes.Buffer
   418  	stringOut := "abc"
   419  	// number of fields that will be encoded * 32
   420  	b.Write(packNum(reflect.ValueOf(32)))
   421  	b.Write(packNum(reflect.ValueOf(len(stringOut))))
   422  	b.Write(common.RightPadBytes([]byte(stringOut), 32))
   423  
   424  	var rst testStruct
   425  	require.NoError(t, abi.Unpack(&rst, "test", b.Bytes()))
   426  	require.Equal(t, [2]uint8{0, 0}, rst.Value1)
   427  	require.Equal(t, stringOut, rst.Value2)
   428  }