github.com/ethereum/go-ethereum@v1.14.3/accounts/abi/bind/util_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 bind_test 18 19 import ( 20 "context" 21 "errors" 22 "math/big" 23 "testing" 24 "time" 25 26 "github.com/ethereum/go-ethereum/accounts/abi/bind" 27 "github.com/ethereum/go-ethereum/common" 28 "github.com/ethereum/go-ethereum/core/types" 29 "github.com/ethereum/go-ethereum/crypto" 30 "github.com/ethereum/go-ethereum/ethclient/simulated" 31 "github.com/ethereum/go-ethereum/params" 32 ) 33 34 var testKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291") 35 36 var waitDeployedTests = map[string]struct { 37 code string 38 gas uint64 39 wantAddress common.Address 40 wantErr error 41 }{ 42 "successful deploy": { 43 code: `6060604052600a8060106000396000f360606040526008565b00`, 44 gas: 3000000, 45 wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"), 46 }, 47 "empty code": { 48 code: ``, 49 gas: 300000, 50 wantErr: bind.ErrNoCodeAfterDeploy, 51 wantAddress: common.HexToAddress("0x3a220f351252089d385b29beca14e27f204c296a"), 52 }, 53 } 54 55 func TestWaitDeployed(t *testing.T) { 56 t.Parallel() 57 for name, test := range waitDeployedTests { 58 backend := simulated.NewBackend( 59 types.GenesisAlloc{ 60 crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}, 61 }, 62 ) 63 defer backend.Close() 64 65 // Create the transaction 66 head, _ := backend.Client().HeaderByNumber(context.Background(), nil) // Should be child's, good enough 67 gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(params.GWei)) 68 69 tx := types.NewContractCreation(0, big.NewInt(0), test.gas, gasPrice, common.FromHex(test.code)) 70 tx, _ = types.SignTx(tx, types.LatestSignerForChainID(big.NewInt(1337)), testKey) 71 72 // Wait for it to get mined in the background. 73 var ( 74 err error 75 address common.Address 76 mined = make(chan struct{}) 77 ctx = context.Background() 78 ) 79 go func() { 80 address, err = bind.WaitDeployed(ctx, backend.Client(), tx) 81 close(mined) 82 }() 83 84 // Send and mine the transaction. 85 backend.Client().SendTransaction(ctx, tx) 86 backend.Commit() 87 88 select { 89 case <-mined: 90 if err != test.wantErr { 91 t.Errorf("test %q: error mismatch: want %q, got %q", name, test.wantErr, err) 92 } 93 if address != test.wantAddress { 94 t.Errorf("test %q: unexpected contract address %s", name, address.Hex()) 95 } 96 case <-time.After(2 * time.Second): 97 t.Errorf("test %q: timeout", name) 98 } 99 } 100 } 101 102 func TestWaitDeployedCornerCases(t *testing.T) { 103 backend := simulated.NewBackend( 104 types.GenesisAlloc{ 105 crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)}, 106 }, 107 ) 108 defer backend.Close() 109 110 head, _ := backend.Client().HeaderByNumber(context.Background(), nil) // Should be child's, good enough 111 gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1)) 112 113 // Create a transaction to an account. 114 code := "6060604052600a8060106000396000f360606040526008565b00" 115 tx := types.NewTransaction(0, common.HexToAddress("0x01"), big.NewInt(0), 3000000, gasPrice, common.FromHex(code)) 116 tx, _ = types.SignTx(tx, types.LatestSigner(params.AllDevChainProtocolChanges), testKey) 117 ctx, cancel := context.WithCancel(context.Background()) 118 defer cancel() 119 backend.Client().SendTransaction(ctx, tx) 120 backend.Commit() 121 notContractCreation := errors.New("tx is not contract creation") 122 if _, err := bind.WaitDeployed(ctx, backend.Client(), tx); err.Error() != notContractCreation.Error() { 123 t.Errorf("error mismatch: want %q, got %q, ", notContractCreation, err) 124 } 125 126 // Create a transaction that is not mined. 127 tx = types.NewContractCreation(1, big.NewInt(0), 3000000, gasPrice, common.FromHex(code)) 128 tx, _ = types.SignTx(tx, types.LatestSigner(params.AllDevChainProtocolChanges), testKey) 129 130 go func() { 131 contextCanceled := errors.New("context canceled") 132 if _, err := bind.WaitDeployed(ctx, backend.Client(), tx); err.Error() != contextCanceled.Error() { 133 t.Errorf("error mismatch: want %q, got %q, ", contextCanceled, err) 134 } 135 }() 136 137 backend.Client().SendTransaction(ctx, tx) 138 cancel() 139 }