export event names in bindings. remove added APIs Filter/Watch-Logs w…

…hich take event ids.

accounts/abi/bind/base.go

@@ -462,25 +462,15 @@ func (c *BoundContract) transact(opts *TransactOpts, contract *common.Address, i
 	return signedTx, nil
 }
 
-// FilterLogsById filters contract logs for past blocks, returning the necessary
-// channels to construct a strongly typed bound iterator on top of them.
-func (c *BoundContract) FilterLogsById(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (<-chan types.Log, event.Subscription, error) {
-	return c.filterLogs(opts, eventID, query...)
-}
-
 // FilterLogs filters contract logs for past blocks, returning the necessary
 // channels to construct a strongly typed bound iterator on top of them.
 func (c *BoundContract) FilterLogs(opts *FilterOpts, name string, query ...[]interface{}) (chan types.Log, event.Subscription, error) {
-	return c.filterLogs(opts, c.abi.Events[name].ID, query...)
-}
-
-func (c *BoundContract) filterLogs(opts *FilterOpts, eventID common.Hash, query ...[]interface{}) (chan types.Log, event.Subscription, error) {
 	// Don't crash on a lazy user
 	if opts == nil {
 		opts = new(FilterOpts)
 	}
 	// Append the event selector to the query parameters and construct the topic set
-	query = append([][]interface{}{{eventID}}, query...)
+	query = append([][]interface{}{{c.abi.Events[name].ID}}, query...)
 	topics, err := abi.MakeTopics(query...)
 	if err != nil {
 		return nil, nil, err

accounts/abi/bind/source2.go.tpl

@@ -120,9 +120,7 @@ var (
 			Raw *types.Log // Blockchain specific contextual infos
 		}
 
-		func {{$contract.Type}}{{.Normalized.Name}}EventID() common.Hash {
-			return common.HexToHash("{{.Original.ID}}")
-		}
+        const {{$contract.Type}}{{.Normalized.Name}}EventName = "{{.Original.Name}}"
 
 		func (_{{$contract.Type}} *{{$contract.Type}}) Unpack{{.Normalized.Name}}Event(log *types.Log) (*{{$contract.Type}}{{.Normalized.Name}}, error) {
 			event := "{{.Original.Name}}"

accounts/abi/bind/v2/lib.go

@@ -30,13 +30,14 @@ import (
 type ContractInstance struct {
 	Address common.Address
 	Backend bind.ContractBackend
+	abi     abi.ABI
 }
 
 // FilterEvents returns an EventIterator instance for filtering historical events based on the event id and a block range.
-func FilterEvents[T any](instance *ContractInstance, opts *bind.FilterOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) {
+func FilterEvents[T any](instance *ContractInstance, opts *bind.FilterOpts, eventName string, unpack func(*types.Log) (*T, error), topics ...[]any) (*EventIterator[T], error) {
 	backend := instance.Backend
-	c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend)
-	logs, sub, err := c.FilterLogsById(opts, eventID, topics...)
+	c := bind.NewBoundContract(instance.Address, instance.abi, backend, backend, backend)
+	logs, sub, err := c.FilterLogs(opts, eventName, topics...)
 	if err != nil {
 		return nil, err
 	}
@@ -47,10 +48,10 @@ func FilterEvents[T any](instance *ContractInstance, opts *bind.FilterOpts, even
 // contract to be intercepted, unpacked, and forwarded to sink.  If
 // unpack returns an error, the returned subscription is closed with the
 // error.
-func WatchEvents[T any](instance *ContractInstance, opts *bind.WatchOpts, eventID common.Hash, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) {
+func WatchEvents[T any](instance *ContractInstance, opts *bind.WatchOpts, eventName string, unpack func(*types.Log) (*T, error), sink chan<- *T, topics ...[]any) (event.Subscription, error) {
 	backend := instance.Backend
-	c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend)
-	logs, sub, err := c.WatchLogsForId(opts, eventID, topics...)
+	c := bind.NewBoundContract(instance.Address, instance.abi, backend, backend, backend)
+	logs, sub, err := c.WatchLogs(opts, eventName, topics...)
 	if err != nil {
 		return nil, err
 	}
@@ -159,15 +160,15 @@ func Transact(instance *ContractInstance, opts *bind.TransactOpts, input []byte)
 		addr    = instance.Address
 		backend = instance.Backend
 	)
-	c := bind.NewBoundContract(addr, abi.ABI{}, backend, backend, backend)
+	c := bind.NewBoundContract(addr, instance.abi, backend, backend, backend)
 	return c.RawTransact(opts, input)
 }
 
 // Call performs an eth_call on the given bound contract instance, using the
 // provided abi-encoded input (or nil).
 func Call[T any](instance *ContractInstance, opts *bind.CallOpts, packedInput []byte, unpack func([]byte) (*T, error)) (*T, error) {
 	backend := instance.Backend
-	c := bind.NewBoundContract(instance.Address, abi.ABI{}, backend, backend, backend)
+	c := bind.NewBoundContract(instance.Address, instance.abi, backend, backend, backend)
 	packedOutput, err := c.CallRaw(opts, packedInput)
 	if err != nil {
 		return nil, err

accounts/abi/bind/v2/lib_test.go

@@ -290,9 +290,11 @@ func TestEvents(t *testing.T) {
 		t.Fatalf("error instantiating contract instance: %v", err)
 	}
 
-	boundContract := ContractInstance{
+	ctrctABI, _ := events.CMetaData.GetAbi()
+	ctrctInstance := ContractInstance{
 		res.Addrs[events.CMetaData.Pattern],
 		backend,
+		*ctrctABI,
 	}
 
 	newCBasic1Ch := make(chan *events.CBasic1)
@@ -301,23 +303,19 @@ func TestEvents(t *testing.T) {
 		Start:   nil,
 		Context: context.Background(),
 	}
-	sub1, err := WatchEvents(&boundContract, watchOpts, events.CBasic1EventID(), ctrct.UnpackBasic1Event, newCBasic1Ch)
+	sub1, err := WatchEvents(&ctrctInstance, watchOpts, events.CBasic1EventName, ctrct.UnpackBasic1Event, newCBasic1Ch)
 	if err != nil {
 		t.Fatalf("WatchEvents returned error: %v", err)
 	}
-	sub2, err := WatchEvents(&boundContract, watchOpts, events.CBasic2EventID(), ctrct.UnpackBasic2Event, newCBasic2Ch)
+	sub2, err := WatchEvents(&ctrctInstance, watchOpts, events.CBasic2EventName, ctrct.UnpackBasic2Event, newCBasic2Ch)
 	if err != nil {
 		t.Fatalf("WatchEvents returned error: %v", err)
 	}
 	defer sub1.Unsubscribe()
 	defer sub2.Unsubscribe()
 
-	crtctInstance := &ContractInstance{
-		Address: res.Addrs[events.CMetaData.Pattern],
-		Backend: backend,
-	}
 	packedInput, _ := ctrct.PackEmitMulti()
-	tx, err := Transact(crtctInstance, txAuth, packedInput)
+	tx, err := Transact(&ctrctInstance, txAuth, packedInput)
 	if err != nil {
 		t.Fatalf("failed to send transaction: %v", err)
 	}
@@ -356,11 +354,11 @@ done:
 		Start:   0,
 		Context: context.Background(),
 	}
-	it, err := FilterEvents[events.CBasic1](crtctInstance, filterOpts, events.CBasic1EventID(), ctrct.UnpackBasic1Event)
+	it, err := FilterEvents[events.CBasic1](&ctrctInstance, filterOpts, events.CBasic1EventName, ctrct.UnpackBasic1Event)
 	if err != nil {
 		t.Fatalf("error filtering logs %v\n", err)
 	}
-	it2, err := FilterEvents[events.CBasic2](crtctInstance, filterOpts, events.CBasic2EventID(), ctrct.UnpackBasic2Event)
+	it2, err := FilterEvents[events.CBasic2](&ctrctInstance, filterOpts, events.CBasic2EventName, ctrct.UnpackBasic2Event)
 	if err != nil {
 		t.Fatalf("error filtering logs %v\n", err)
 	}
@@ -409,7 +407,8 @@ func TestErrors(t *testing.T) {
 	}
 	packedInput, _ = ctrct.PackFoo()
 
-	instance := ContractInstance{res.Addrs[solc_errors.CMetaData.Pattern], backend}
+	ctrctABI, _ := solc_errors.CMetaData.GetAbi()
+	instance := ContractInstance{res.Addrs[solc_errors.CMetaData.Pattern], backend, *ctrctABI}
 	_, err = Call[struct{}](&instance, opts, packedInput, func(packed []byte) (*struct{}, error) { return nil, nil })
 	if err == nil {
 		t.Fatalf("expected call to fail")