Merge go-ethereum v1.16.4

.github/workflows/validate_pr.yml

@@ -13,7 +13,7 @@ jobs:
         with:
           script: |
             const prTitle = context.payload.pull_request.title;
-            const titleRegex = /^(\.?[\w\s,{}/]+): .+/;
+            const titleRegex = /^([\w\s,{}/.]+): .+/;
             
             if (!titleRegex.test(prTitle)) {
               core.setFailed(`PR title "${prTitle}" does not match required format: directory, ...: description`);

accounts/abi/bind/v2/base.go

@@ -150,6 +150,11 @@ func NewBoundContract(address common.Address, abi abi.ABI, caller ContractCaller
 	}
 }
 
+// Address returns the deployment address of the contract.
+func (c *BoundContract) Address() common.Address {
+	return c.address
+}
+
 // Call invokes the (constant) contract method with params as input values and
 // sets the output to result. The result type might be a single field for simple
 // returns, a slice of interfaces for anonymous returns and a struct for named

accounts/abi/bind/v2/util_test.go

@@ -100,22 +100,29 @@ func TestWaitDeployed(t *testing.T) {
 }
 
 func TestWaitDeployedCornerCases(t *testing.T) {
-	backend := simulated.NewBackend(
-		types.GenesisAlloc{
-			crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
-		},
+	var (
+		backend = simulated.NewBackend(
+			types.GenesisAlloc{
+				crypto.PubkeyToAddress(testKey.PublicKey): {Balance: big.NewInt(10000000000000000)},
+			},
+		)
+		head, _     = backend.Client().HeaderByNumber(context.Background(), nil) // Should be child's, good enough
+		gasPrice    = new(big.Int).Add(head.BaseFee, big.NewInt(1))
+		signer      = types.LatestSigner(params.AllDevChainProtocolChanges)
+		code        = common.FromHex("6060604052600a8060106000396000f360606040526008565b00")
+		ctx, cancel = context.WithCancel(context.Background())
 	)
 	defer backend.Close()
 
-	head, _ := backend.Client().HeaderByNumber(context.Background(), nil) // Should be child's, good enough
-	gasPrice := new(big.Int).Add(head.BaseFee, big.NewInt(1))
-
-	// Create a transaction to an account.
-	code := "6060604052600a8060106000396000f360606040526008565b00"
-	tx := types.NewTransaction(0, common.HexToAddress("0x01"), big.NewInt(0), 3000000, gasPrice, common.FromHex(code))
-	tx, _ = types.SignTx(tx, types.LatestSigner(params.AllDevChainProtocolChanges), testKey)
-	ctx, cancel := context.WithCancel(context.Background())
-	defer cancel()
+	// 1. WaitDeploy on a transaction that does not deploy a contract, verify it
+	// returns an error.
+	tx := types.MustSignNewTx(testKey, signer, &types.LegacyTx{
+		Nonce:    0,
+		To:       &common.Address{0x01},
+		Gas:      300000,
+		GasPrice: gasPrice,
+		Data:     code,
+	})
 	if err := backend.Client().SendTransaction(ctx, tx); err != nil {
 		t.Errorf("failed to send transaction: %q", err)
 	}
@@ -124,19 +131,35 @@ func TestWaitDeployedCornerCases(t *testing.T) {
 		t.Errorf("error mismatch: want %q, got %q, ", bind.ErrNoAddressInReceipt, err)
 	}
 
-	// Create a transaction that is not mined.
-	tx = types.NewContractCreation(1, big.NewInt(0), 3000000, gasPrice, common.FromHex(code))
-	tx, _ = types.SignTx(tx, types.LatestSigner(params.AllDevChainProtocolChanges), testKey)
-
+	// 2. Create a contract, but cancel the WaitDeploy before it is mined.
+	tx = types.MustSignNewTx(testKey, signer, &types.LegacyTx{
+		Nonce:    1,
+		Gas:      300000,
+		GasPrice: gasPrice,
+		Data:     code,
+	})
+
+	// Wait in another thread so that we can quickly cancel it after submitting
+	// the transaction.
+	done := make(chan struct{})
 	go func() {
-		contextCanceled := errors.New("context canceled")
-		if _, err := bind.WaitDeployed(ctx, backend.Client(), tx.Hash()); err.Error() != contextCanceled.Error() {
-			t.Errorf("error mismatch: want %q, got %q, ", contextCanceled, err)
+		defer close(done)
+		want := errors.New("context canceled")
+		_, err := bind.WaitDeployed(ctx, backend.Client(), tx.Hash())
+		if err == nil || errors.Is(want, err) {
+			t.Errorf("error mismatch: want %v, got %v", want, err)
 		}
 	}()
 
 	if err := backend.Client().SendTransaction(ctx, tx); err != nil {
 		t.Errorf("failed to send transaction: %q", err)
 	}
 	cancel()
+
+	// Wait for goroutine to exit or for a timeout.
+	select {
+	case <-done:
+	case <-time.After(time.Second * 2):
+		t.Fatalf("failed to cancel wait deploy")
+	}
 }

accounts/keystore/keystore.go

@@ -102,6 +102,7 @@ func (ks *KeyStore) init(keydir string) {
 	runtime.SetFinalizer(ks, func(m *KeyStore) {
 		m.cache.close()
 	})
+
 	// Create the initial list of wallets from the cache
 	accs := ks.cache.accounts()
 	ks.wallets = make([]accounts.Wallet, len(accs))
@@ -195,11 +196,14 @@ func (ks *KeyStore) Subscribe(sink chan<- accounts.WalletEvent) event.Subscripti
 // forces a manual refresh (only triggers for systems where the filesystem notifier
 // is not running).
 func (ks *KeyStore) updater() {
+	ticker := time.NewTicker(walletRefreshCycle)
+	defer ticker.Stop()
+
 	for {
 		// Wait for an account update or a refresh timeout
 		select {
 		case <-ks.changes:
-		case <-time.After(walletRefreshCycle):
+		case <-ticker.C:
 		}
 		// Run the wallet refresher
 		ks.refreshWallets()