123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257 |
- // Copyright 2019 The go-ethereum Authors
- // This file is part of the go-ethereum library.
- //
- // The go-ethereum library is free software: you can redistribute it and/or modify
- // it under the terms of the GNU Lesser General Public License as published by
- // the Free Software Foundation, either version 3 of the License, or
- // (at your option) any later version.
- //
- // The go-ethereum library is distributed in the hope that it will be useful,
- // but WITHOUT ANY WARRANTY; without even the implied warranty of
- // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- // GNU Lesser General Public License for more details.
- //
- // You should have received a copy of the GNU Lesser General Public License
- // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
- package bind_test
- import (
- "context"
- "math/big"
- "reflect"
- "strings"
- "testing"
- "github.com/ethereum/go-ethereum"
- "github.com/ethereum/go-ethereum/accounts/abi"
- "github.com/ethereum/go-ethereum/accounts/abi/bind"
- "github.com/ethereum/go-ethereum/common"
- "github.com/ethereum/go-ethereum/common/hexutil"
- "github.com/ethereum/go-ethereum/core/types"
- "github.com/ethereum/go-ethereum/crypto"
- "github.com/ethereum/go-ethereum/rlp"
- )
- type mockCaller struct {
- codeAtBlockNumber *big.Int
- callContractBlockNumber *big.Int
- pendingCodeAtCalled bool
- pendingCallContractCalled bool
- }
- func (mc *mockCaller) CodeAt(ctx context.Context, contract common.Address, blockNumber *big.Int) ([]byte, error) {
- mc.codeAtBlockNumber = blockNumber
- return []byte{1, 2, 3}, nil
- }
- func (mc *mockCaller) CallContract(ctx context.Context, call ethereum.CallMsg, blockNumber *big.Int) ([]byte, error) {
- mc.callContractBlockNumber = blockNumber
- return nil, nil
- }
- func (mc *mockCaller) PendingCodeAt(ctx context.Context, contract common.Address) ([]byte, error) {
- mc.pendingCodeAtCalled = true
- return nil, nil
- }
- func (mc *mockCaller) PendingCallContract(ctx context.Context, call ethereum.CallMsg) ([]byte, error) {
- mc.pendingCallContractCalled = true
- return nil, nil
- }
- func TestPassingBlockNumber(t *testing.T) {
- mc := &mockCaller{}
- bc := bind.NewBoundContract(common.HexToAddress("0x0"), abi.ABI{
- Methods: map[string]abi.Method{
- "something": {
- Name: "something",
- Outputs: abi.Arguments{},
- },
- },
- }, mc, nil, nil)
- blockNumber := big.NewInt(42)
- bc.Call(&bind.CallOpts{BlockNumber: blockNumber}, nil, "something")
- if mc.callContractBlockNumber != blockNumber {
- t.Fatalf("CallContract() was not passed the block number")
- }
- if mc.codeAtBlockNumber != blockNumber {
- t.Fatalf("CodeAt() was not passed the block number")
- }
- bc.Call(&bind.CallOpts{}, nil, "something")
- if mc.callContractBlockNumber != nil {
- t.Fatalf("CallContract() was passed a block number when it should not have been")
- }
- if mc.codeAtBlockNumber != nil {
- t.Fatalf("CodeAt() was passed a block number when it should not have been")
- }
- bc.Call(&bind.CallOpts{BlockNumber: blockNumber, Pending: true}, nil, "something")
- if !mc.pendingCallContractCalled {
- t.Fatalf("CallContract() was not passed the block number")
- }
- if !mc.pendingCodeAtCalled {
- t.Fatalf("CodeAt() was not passed the block number")
- }
- }
- const hexData = "0x000000000000000000000000376c47978271565f56deb45495afa69e59c16ab200000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000060000000000000000000000000000000000000000000000000000000000000000158"
- func TestUnpackIndexedStringTyLogIntoMap(t *testing.T) {
- hash := crypto.Keccak256Hash([]byte("testName"))
- topics := []common.Hash{
- common.HexToHash("0x0"),
- hash,
- }
- mockLog := newMockLog(topics, common.HexToHash("0x0"))
- abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"name","type":"string"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
- parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
- bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
- expectedReceivedMap := map[string]interface{}{
- "name": hash,
- "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
- "amount": big.NewInt(1),
- "memo": []byte{88},
- }
- unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
- }
- func TestUnpackIndexedSliceTyLogIntoMap(t *testing.T) {
- sliceBytes, err := rlp.EncodeToBytes([]string{"name1", "name2", "name3", "name4"})
- if err != nil {
- t.Fatal(err)
- }
- hash := crypto.Keccak256Hash(sliceBytes)
- topics := []common.Hash{
- common.HexToHash("0x0"),
- hash,
- }
- mockLog := newMockLog(topics, common.HexToHash("0x0"))
- abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"names","type":"string[]"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
- parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
- bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
- expectedReceivedMap := map[string]interface{}{
- "names": hash,
- "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
- "amount": big.NewInt(1),
- "memo": []byte{88},
- }
- unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
- }
- func TestUnpackIndexedArrayTyLogIntoMap(t *testing.T) {
- arrBytes, err := rlp.EncodeToBytes([2]common.Address{common.HexToAddress("0x0"), common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2")})
- if err != nil {
- t.Fatal(err)
- }
- hash := crypto.Keccak256Hash(arrBytes)
- topics := []common.Hash{
- common.HexToHash("0x0"),
- hash,
- }
- mockLog := newMockLog(topics, common.HexToHash("0x0"))
- abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"addresses","type":"address[2]"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
- parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
- bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
- expectedReceivedMap := map[string]interface{}{
- "addresses": hash,
- "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
- "amount": big.NewInt(1),
- "memo": []byte{88},
- }
- unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
- }
- func TestUnpackIndexedFuncTyLogIntoMap(t *testing.T) {
- mockAddress := common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2")
- addrBytes := mockAddress.Bytes()
- hash := crypto.Keccak256Hash([]byte("mockFunction(address,uint)"))
- functionSelector := hash[:4]
- functionTyBytes := append(addrBytes, functionSelector...)
- var functionTy [24]byte
- copy(functionTy[:], functionTyBytes[0:24])
- topics := []common.Hash{
- common.HexToHash("0x99b5620489b6ef926d4518936cfec15d305452712b88bd59da2d9c10fb0953e8"),
- common.BytesToHash(functionTyBytes),
- }
- mockLog := newMockLog(topics, common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42"))
- abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"function","type":"function"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
- parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
- bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
- expectedReceivedMap := map[string]interface{}{
- "function": functionTy,
- "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
- "amount": big.NewInt(1),
- "memo": []byte{88},
- }
- unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
- }
- func TestUnpackIndexedBytesTyLogIntoMap(t *testing.T) {
- bytes := []byte{1, 2, 3, 4, 5}
- hash := crypto.Keccak256Hash(bytes)
- topics := []common.Hash{
- common.HexToHash("0x99b5620489b6ef926d4518936cfec15d305452712b88bd59da2d9c10fb0953e8"),
- hash,
- }
- mockLog := newMockLog(topics, common.HexToHash("0x5c698f13940a2153440c6d19660878bc90219d9298fdcf37365aa8d88d40fc42"))
- abiString := `[{"anonymous":false,"inputs":[{"indexed":true,"name":"content","type":"bytes"},{"indexed":false,"name":"sender","type":"address"},{"indexed":false,"name":"amount","type":"uint256"},{"indexed":false,"name":"memo","type":"bytes"}],"name":"received","type":"event"}]`
- parsedAbi, _ := abi.JSON(strings.NewReader(abiString))
- bc := bind.NewBoundContract(common.HexToAddress("0x0"), parsedAbi, nil, nil, nil)
- expectedReceivedMap := map[string]interface{}{
- "content": hash,
- "sender": common.HexToAddress("0x376c47978271565f56DEB45495afa69E59c16Ab2"),
- "amount": big.NewInt(1),
- "memo": []byte{88},
- }
- unpackAndCheck(t, bc, expectedReceivedMap, mockLog)
- }
- func unpackAndCheck(t *testing.T, bc *bind.BoundContract, expected map[string]interface{}, mockLog types.Log) {
- received := make(map[string]interface{})
- if err := bc.UnpackLogIntoMap(received, "received", mockLog); err != nil {
- t.Error(err)
- }
- if len(received) != len(expected) {
- t.Fatalf("unpacked map length %v not equal expected length of %v", len(received), len(expected))
- }
- for name, elem := range expected {
- if !reflect.DeepEqual(elem, received[name]) {
- t.Errorf("field %v does not match expected, want %v, got %v", name, elem, received[name])
- }
- }
- }
- func newMockLog(topics []common.Hash, txHash common.Hash) types.Log {
- return types.Log{
- Address: common.HexToAddress("0x0"),
- Topics: topics,
- Data: hexutil.MustDecode(hexData),
- BlockNumber: uint64(26),
- TxHash: txHash,
- TxIndex: 111,
- BlockHash: common.BytesToHash([]byte{1, 2, 3, 4, 5}),
- Index: 7,
- Removed: false,
- }
- }
|