github.com/0xPolygon/supernets2-node@v0.0.0-20230711153321-2fe574524eaa/test/contracts/bin/EmitLog/EmitLog.go (about)

     1  // Code generated - DO NOT EDIT.
     2  // This file is a generated binding and any manual changes will be lost.
     3  
     4  package EmitLog
     5  
     6  import (
     7  	"errors"
     8  	"math/big"
     9  	"strings"
    10  
    11  	ethereum "github.com/ethereum/go-ethereum"
    12  	"github.com/ethereum/go-ethereum/accounts/abi"
    13  	"github.com/ethereum/go-ethereum/accounts/abi/bind"
    14  	"github.com/ethereum/go-ethereum/common"
    15  	"github.com/ethereum/go-ethereum/core/types"
    16  	"github.com/ethereum/go-ethereum/event"
    17  )
    18  
    19  // Reference imports to suppress errors if they are not otherwise used.
    20  var (
    21  	_ = errors.New
    22  	_ = big.NewInt
    23  	_ = strings.NewReader
    24  	_ = ethereum.NotFound
    25  	_ = bind.Bind
    26  	_ = common.Big1
    27  	_ = types.BloomLookup
    28  	_ = event.NewSubscription
    29  	_ = abi.ConvertType
    30  )
    31  
    32  // EmitLogMetaData contains all meta data concerning the EmitLog contract.
    33  var EmitLogMetaData = &bind.MetaData{
    34  	ABI: "[{\"anonymous\":false,\"inputs\":[],\"name\":\"Log\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"}],\"name\":\"LogA\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"b\",\"type\":\"uint256\"}],\"name\":\"LogAB\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"b\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"c\",\"type\":\"uint256\"}],\"name\":\"LogABC\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"a\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"b\",\"type\":\"uint256\"},{\"indexed\":true,\"internalType\":\"uint256\",\"name\":\"c\",\"type\":\"uint256\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"d\",\"type\":\"uint256\"}],\"name\":\"LogABCD\",\"type\":\"event\"},{\"inputs\":[],\"name\":\"emitLogs\",\"outputs\":[],\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]",
    35  	Bin: "0x608060405234801561001057600080fd5b5061025e806100206000396000f3fe608060405234801561001057600080fd5b506004361061002b5760003560e01c80637966b4f614610030575b600080fd5b61003861003a565b005b6040517f5e7df75d54e493185612379c616118a4c9ac802de621b010c96f74d22df4b30a90600090a16040516001907f977224b24e70d33f3be87246a29c5636cfc8dd6853e175b54af01ff493ffac6290600090a26040516002906001907fbb6e4da744abea70325874159d52c1ad3e57babfae7c329a948e7dcb274deb0990600090a36003600260017f966018f1afaee50c6bcf5eb4ae089eeb650bd1deb473395d69dd307ef2e689b760405160405180910390a46003600260017fe5562b12d9276c5c987df08afff7b1946f2d869236866ea2285c7e2e95685a64600460405161012891815260200190565b60405180910390a46002600360047fe5562b12d9276c5c987df08afff7b1946f2d869236866ea2285c7e2e95685a64600160405161016891815260200190565b60405180910390a46001600260037f966018f1afaee50c6bcf5eb4ae089eeb650bd1deb473395d69dd307ef2e689b760405160405180910390a46040516001906002907fbb6e4da744abea70325874159d52c1ad3e57babfae7c329a948e7dcb274deb0990600090a36040516001907f977224b24e70d33f3be87246a29c5636cfc8dd6853e175b54af01ff493ffac6290600090a26040517f5e7df75d54e493185612379c616118a4c9ac802de621b010c96f74d22df4b30a90600090a156fea26469706673582212204c9779aabd3e8dfef2bffe2d88075ca74555273b14d3766908a126f2cf434b8964736f6c634300080c0033",
    36  }
    37  
    38  // EmitLogABI is the input ABI used to generate the binding from.
    39  // Deprecated: Use EmitLogMetaData.ABI instead.
    40  var EmitLogABI = EmitLogMetaData.ABI
    41  
    42  // EmitLogBin is the compiled bytecode used for deploying new contracts.
    43  // Deprecated: Use EmitLogMetaData.Bin instead.
    44  var EmitLogBin = EmitLogMetaData.Bin
    45  
    46  // DeployEmitLog deploys a new Ethereum contract, binding an instance of EmitLog to it.
    47  func DeployEmitLog(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *EmitLog, error) {
    48  	parsed, err := EmitLogMetaData.GetAbi()
    49  	if err != nil {
    50  		return common.Address{}, nil, nil, err
    51  	}
    52  	if parsed == nil {
    53  		return common.Address{}, nil, nil, errors.New("GetABI returned nil")
    54  	}
    55  
    56  	address, tx, contract, err := bind.DeployContract(auth, *parsed, common.FromHex(EmitLogBin), backend)
    57  	if err != nil {
    58  		return common.Address{}, nil, nil, err
    59  	}
    60  	return address, tx, &EmitLog{EmitLogCaller: EmitLogCaller{contract: contract}, EmitLogTransactor: EmitLogTransactor{contract: contract}, EmitLogFilterer: EmitLogFilterer{contract: contract}}, nil
    61  }
    62  
    63  // EmitLog is an auto generated Go binding around an Ethereum contract.
    64  type EmitLog struct {
    65  	EmitLogCaller     // Read-only binding to the contract
    66  	EmitLogTransactor // Write-only binding to the contract
    67  	EmitLogFilterer   // Log filterer for contract events
    68  }
    69  
    70  // EmitLogCaller is an auto generated read-only Go binding around an Ethereum contract.
    71  type EmitLogCaller struct {
    72  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
    73  }
    74  
    75  // EmitLogTransactor is an auto generated write-only Go binding around an Ethereum contract.
    76  type EmitLogTransactor struct {
    77  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
    78  }
    79  
    80  // EmitLogFilterer is an auto generated log filtering Go binding around an Ethereum contract events.
    81  type EmitLogFilterer struct {
    82  	contract *bind.BoundContract // Generic contract wrapper for the low level calls
    83  }
    84  
    85  // EmitLogSession is an auto generated Go binding around an Ethereum contract,
    86  // with pre-set call and transact options.
    87  type EmitLogSession struct {
    88  	Contract     *EmitLog          // Generic contract binding to set the session for
    89  	CallOpts     bind.CallOpts     // Call options to use throughout this session
    90  	TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session
    91  }
    92  
    93  // EmitLogCallerSession is an auto generated read-only Go binding around an Ethereum contract,
    94  // with pre-set call options.
    95  type EmitLogCallerSession struct {
    96  	Contract *EmitLogCaller // Generic contract caller binding to set the session for
    97  	CallOpts bind.CallOpts  // Call options to use throughout this session
    98  }
    99  
   100  // EmitLogTransactorSession is an auto generated write-only Go binding around an Ethereum contract,
   101  // with pre-set transact options.
   102  type EmitLogTransactorSession struct {
   103  	Contract     *EmitLogTransactor // Generic contract transactor binding to set the session for
   104  	TransactOpts bind.TransactOpts  // Transaction auth options to use throughout this session
   105  }
   106  
   107  // EmitLogRaw is an auto generated low-level Go binding around an Ethereum contract.
   108  type EmitLogRaw struct {
   109  	Contract *EmitLog // Generic contract binding to access the raw methods on
   110  }
   111  
   112  // EmitLogCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract.
   113  type EmitLogCallerRaw struct {
   114  	Contract *EmitLogCaller // Generic read-only contract binding to access the raw methods on
   115  }
   116  
   117  // EmitLogTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract.
   118  type EmitLogTransactorRaw struct {
   119  	Contract *EmitLogTransactor // Generic write-only contract binding to access the raw methods on
   120  }
   121  
   122  // NewEmitLog creates a new instance of EmitLog, bound to a specific deployed contract.
   123  func NewEmitLog(address common.Address, backend bind.ContractBackend) (*EmitLog, error) {
   124  	contract, err := bindEmitLog(address, backend, backend, backend)
   125  	if err != nil {
   126  		return nil, err
   127  	}
   128  	return &EmitLog{EmitLogCaller: EmitLogCaller{contract: contract}, EmitLogTransactor: EmitLogTransactor{contract: contract}, EmitLogFilterer: EmitLogFilterer{contract: contract}}, nil
   129  }
   130  
   131  // NewEmitLogCaller creates a new read-only instance of EmitLog, bound to a specific deployed contract.
   132  func NewEmitLogCaller(address common.Address, caller bind.ContractCaller) (*EmitLogCaller, error) {
   133  	contract, err := bindEmitLog(address, caller, nil, nil)
   134  	if err != nil {
   135  		return nil, err
   136  	}
   137  	return &EmitLogCaller{contract: contract}, nil
   138  }
   139  
   140  // NewEmitLogTransactor creates a new write-only instance of EmitLog, bound to a specific deployed contract.
   141  func NewEmitLogTransactor(address common.Address, transactor bind.ContractTransactor) (*EmitLogTransactor, error) {
   142  	contract, err := bindEmitLog(address, nil, transactor, nil)
   143  	if err != nil {
   144  		return nil, err
   145  	}
   146  	return &EmitLogTransactor{contract: contract}, nil
   147  }
   148  
   149  // NewEmitLogFilterer creates a new log filterer instance of EmitLog, bound to a specific deployed contract.
   150  func NewEmitLogFilterer(address common.Address, filterer bind.ContractFilterer) (*EmitLogFilterer, error) {
   151  	contract, err := bindEmitLog(address, nil, nil, filterer)
   152  	if err != nil {
   153  		return nil, err
   154  	}
   155  	return &EmitLogFilterer{contract: contract}, nil
   156  }
   157  
   158  // bindEmitLog binds a generic wrapper to an already deployed contract.
   159  func bindEmitLog(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) {
   160  	parsed, err := EmitLogMetaData.GetAbi()
   161  	if err != nil {
   162  		return nil, err
   163  	}
   164  	return bind.NewBoundContract(address, *parsed, caller, transactor, filterer), nil
   165  }
   166  
   167  // Call invokes the (constant) contract method with params as input values and
   168  // sets the output to result. The result type might be a single field for simple
   169  // returns, a slice of interfaces for anonymous returns and a struct for named
   170  // returns.
   171  func (_EmitLog *EmitLogRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
   172  	return _EmitLog.Contract.EmitLogCaller.contract.Call(opts, result, method, params...)
   173  }
   174  
   175  // Transfer initiates a plain transaction to move funds to the contract, calling
   176  // its default method if one is available.
   177  func (_EmitLog *EmitLogRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   178  	return _EmitLog.Contract.EmitLogTransactor.contract.Transfer(opts)
   179  }
   180  
   181  // Transact invokes the (paid) contract method with params as input values.
   182  func (_EmitLog *EmitLogRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   183  	return _EmitLog.Contract.EmitLogTransactor.contract.Transact(opts, method, params...)
   184  }
   185  
   186  // Call invokes the (constant) contract method with params as input values and
   187  // sets the output to result. The result type might be a single field for simple
   188  // returns, a slice of interfaces for anonymous returns and a struct for named
   189  // returns.
   190  func (_EmitLog *EmitLogCallerRaw) Call(opts *bind.CallOpts, result *[]interface{}, method string, params ...interface{}) error {
   191  	return _EmitLog.Contract.contract.Call(opts, result, method, params...)
   192  }
   193  
   194  // Transfer initiates a plain transaction to move funds to the contract, calling
   195  // its default method if one is available.
   196  func (_EmitLog *EmitLogTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) {
   197  	return _EmitLog.Contract.contract.Transfer(opts)
   198  }
   199  
   200  // Transact invokes the (paid) contract method with params as input values.
   201  func (_EmitLog *EmitLogTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) {
   202  	return _EmitLog.Contract.contract.Transact(opts, method, params...)
   203  }
   204  
   205  // EmitLogs is a paid mutator transaction binding the contract method 0x7966b4f6.
   206  //
   207  // Solidity: function emitLogs() returns()
   208  func (_EmitLog *EmitLogTransactor) EmitLogs(opts *bind.TransactOpts) (*types.Transaction, error) {
   209  	return _EmitLog.contract.Transact(opts, "emitLogs")
   210  }
   211  
   212  // EmitLogs is a paid mutator transaction binding the contract method 0x7966b4f6.
   213  //
   214  // Solidity: function emitLogs() returns()
   215  func (_EmitLog *EmitLogSession) EmitLogs() (*types.Transaction, error) {
   216  	return _EmitLog.Contract.EmitLogs(&_EmitLog.TransactOpts)
   217  }
   218  
   219  // EmitLogs is a paid mutator transaction binding the contract method 0x7966b4f6.
   220  //
   221  // Solidity: function emitLogs() returns()
   222  func (_EmitLog *EmitLogTransactorSession) EmitLogs() (*types.Transaction, error) {
   223  	return _EmitLog.Contract.EmitLogs(&_EmitLog.TransactOpts)
   224  }
   225  
   226  // EmitLogLogIterator is returned from FilterLog and is used to iterate over the raw logs and unpacked data for Log events raised by the EmitLog contract.
   227  type EmitLogLogIterator struct {
   228  	Event *EmitLogLog // Event containing the contract specifics and raw log
   229  
   230  	contract *bind.BoundContract // Generic contract to use for unpacking event data
   231  	event    string              // Event name to use for unpacking event data
   232  
   233  	logs chan types.Log        // Log channel receiving the found contract events
   234  	sub  ethereum.Subscription // Subscription for errors, completion and termination
   235  	done bool                  // Whether the subscription completed delivering logs
   236  	fail error                 // Occurred error to stop iteration
   237  }
   238  
   239  // Next advances the iterator to the subsequent event, returning whether there
   240  // are any more events found. In case of a retrieval or parsing error, false is
   241  // returned and Error() can be queried for the exact failure.
   242  func (it *EmitLogLogIterator) Next() bool {
   243  	// If the iterator failed, stop iterating
   244  	if it.fail != nil {
   245  		return false
   246  	}
   247  	// If the iterator completed, deliver directly whatever's available
   248  	if it.done {
   249  		select {
   250  		case log := <-it.logs:
   251  			it.Event = new(EmitLogLog)
   252  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   253  				it.fail = err
   254  				return false
   255  			}
   256  			it.Event.Raw = log
   257  			return true
   258  
   259  		default:
   260  			return false
   261  		}
   262  	}
   263  	// Iterator still in progress, wait for either a data or an error event
   264  	select {
   265  	case log := <-it.logs:
   266  		it.Event = new(EmitLogLog)
   267  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   268  			it.fail = err
   269  			return false
   270  		}
   271  		it.Event.Raw = log
   272  		return true
   273  
   274  	case err := <-it.sub.Err():
   275  		it.done = true
   276  		it.fail = err
   277  		return it.Next()
   278  	}
   279  }
   280  
   281  // Error returns any retrieval or parsing error occurred during filtering.
   282  func (it *EmitLogLogIterator) Error() error {
   283  	return it.fail
   284  }
   285  
   286  // Close terminates the iteration process, releasing any pending underlying
   287  // resources.
   288  func (it *EmitLogLogIterator) Close() error {
   289  	it.sub.Unsubscribe()
   290  	return nil
   291  }
   292  
   293  // EmitLogLog represents a Log event raised by the EmitLog contract.
   294  type EmitLogLog struct {
   295  	Raw types.Log // Blockchain specific contextual infos
   296  }
   297  
   298  // FilterLog is a free log retrieval operation binding the contract event 0x5e7df75d54e493185612379c616118a4c9ac802de621b010c96f74d22df4b30a.
   299  //
   300  // Solidity: event Log()
   301  func (_EmitLog *EmitLogFilterer) FilterLog(opts *bind.FilterOpts) (*EmitLogLogIterator, error) {
   302  
   303  	logs, sub, err := _EmitLog.contract.FilterLogs(opts, "Log")
   304  	if err != nil {
   305  		return nil, err
   306  	}
   307  	return &EmitLogLogIterator{contract: _EmitLog.contract, event: "Log", logs: logs, sub: sub}, nil
   308  }
   309  
   310  // WatchLog is a free log subscription operation binding the contract event 0x5e7df75d54e493185612379c616118a4c9ac802de621b010c96f74d22df4b30a.
   311  //
   312  // Solidity: event Log()
   313  func (_EmitLog *EmitLogFilterer) WatchLog(opts *bind.WatchOpts, sink chan<- *EmitLogLog) (event.Subscription, error) {
   314  
   315  	logs, sub, err := _EmitLog.contract.WatchLogs(opts, "Log")
   316  	if err != nil {
   317  		return nil, err
   318  	}
   319  	return event.NewSubscription(func(quit <-chan struct{}) error {
   320  		defer sub.Unsubscribe()
   321  		for {
   322  			select {
   323  			case log := <-logs:
   324  				// New log arrived, parse the event and forward to the user
   325  				event := new(EmitLogLog)
   326  				if err := _EmitLog.contract.UnpackLog(event, "Log", log); err != nil {
   327  					return err
   328  				}
   329  				event.Raw = log
   330  
   331  				select {
   332  				case sink <- event:
   333  				case err := <-sub.Err():
   334  					return err
   335  				case <-quit:
   336  					return nil
   337  				}
   338  			case err := <-sub.Err():
   339  				return err
   340  			case <-quit:
   341  				return nil
   342  			}
   343  		}
   344  	}), nil
   345  }
   346  
   347  // ParseLog is a log parse operation binding the contract event 0x5e7df75d54e493185612379c616118a4c9ac802de621b010c96f74d22df4b30a.
   348  //
   349  // Solidity: event Log()
   350  func (_EmitLog *EmitLogFilterer) ParseLog(log types.Log) (*EmitLogLog, error) {
   351  	event := new(EmitLogLog)
   352  	if err := _EmitLog.contract.UnpackLog(event, "Log", log); err != nil {
   353  		return nil, err
   354  	}
   355  	event.Raw = log
   356  	return event, nil
   357  }
   358  
   359  // EmitLogLogAIterator is returned from FilterLogA and is used to iterate over the raw logs and unpacked data for LogA events raised by the EmitLog contract.
   360  type EmitLogLogAIterator struct {
   361  	Event *EmitLogLogA // Event containing the contract specifics and raw log
   362  
   363  	contract *bind.BoundContract // Generic contract to use for unpacking event data
   364  	event    string              // Event name to use for unpacking event data
   365  
   366  	logs chan types.Log        // Log channel receiving the found contract events
   367  	sub  ethereum.Subscription // Subscription for errors, completion and termination
   368  	done bool                  // Whether the subscription completed delivering logs
   369  	fail error                 // Occurred error to stop iteration
   370  }
   371  
   372  // Next advances the iterator to the subsequent event, returning whether there
   373  // are any more events found. In case of a retrieval or parsing error, false is
   374  // returned and Error() can be queried for the exact failure.
   375  func (it *EmitLogLogAIterator) Next() bool {
   376  	// If the iterator failed, stop iterating
   377  	if it.fail != nil {
   378  		return false
   379  	}
   380  	// If the iterator completed, deliver directly whatever's available
   381  	if it.done {
   382  		select {
   383  		case log := <-it.logs:
   384  			it.Event = new(EmitLogLogA)
   385  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   386  				it.fail = err
   387  				return false
   388  			}
   389  			it.Event.Raw = log
   390  			return true
   391  
   392  		default:
   393  			return false
   394  		}
   395  	}
   396  	// Iterator still in progress, wait for either a data or an error event
   397  	select {
   398  	case log := <-it.logs:
   399  		it.Event = new(EmitLogLogA)
   400  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   401  			it.fail = err
   402  			return false
   403  		}
   404  		it.Event.Raw = log
   405  		return true
   406  
   407  	case err := <-it.sub.Err():
   408  		it.done = true
   409  		it.fail = err
   410  		return it.Next()
   411  	}
   412  }
   413  
   414  // Error returns any retrieval or parsing error occurred during filtering.
   415  func (it *EmitLogLogAIterator) Error() error {
   416  	return it.fail
   417  }
   418  
   419  // Close terminates the iteration process, releasing any pending underlying
   420  // resources.
   421  func (it *EmitLogLogAIterator) Close() error {
   422  	it.sub.Unsubscribe()
   423  	return nil
   424  }
   425  
   426  // EmitLogLogA represents a LogA event raised by the EmitLog contract.
   427  type EmitLogLogA struct {
   428  	A   *big.Int
   429  	Raw types.Log // Blockchain specific contextual infos
   430  }
   431  
   432  // FilterLogA is a free log retrieval operation binding the contract event 0x977224b24e70d33f3be87246a29c5636cfc8dd6853e175b54af01ff493ffac62.
   433  //
   434  // Solidity: event LogA(uint256 indexed a)
   435  func (_EmitLog *EmitLogFilterer) FilterLogA(opts *bind.FilterOpts, a []*big.Int) (*EmitLogLogAIterator, error) {
   436  
   437  	var aRule []interface{}
   438  	for _, aItem := range a {
   439  		aRule = append(aRule, aItem)
   440  	}
   441  
   442  	logs, sub, err := _EmitLog.contract.FilterLogs(opts, "LogA", aRule)
   443  	if err != nil {
   444  		return nil, err
   445  	}
   446  	return &EmitLogLogAIterator{contract: _EmitLog.contract, event: "LogA", logs: logs, sub: sub}, nil
   447  }
   448  
   449  // WatchLogA is a free log subscription operation binding the contract event 0x977224b24e70d33f3be87246a29c5636cfc8dd6853e175b54af01ff493ffac62.
   450  //
   451  // Solidity: event LogA(uint256 indexed a)
   452  func (_EmitLog *EmitLogFilterer) WatchLogA(opts *bind.WatchOpts, sink chan<- *EmitLogLogA, a []*big.Int) (event.Subscription, error) {
   453  
   454  	var aRule []interface{}
   455  	for _, aItem := range a {
   456  		aRule = append(aRule, aItem)
   457  	}
   458  
   459  	logs, sub, err := _EmitLog.contract.WatchLogs(opts, "LogA", aRule)
   460  	if err != nil {
   461  		return nil, err
   462  	}
   463  	return event.NewSubscription(func(quit <-chan struct{}) error {
   464  		defer sub.Unsubscribe()
   465  		for {
   466  			select {
   467  			case log := <-logs:
   468  				// New log arrived, parse the event and forward to the user
   469  				event := new(EmitLogLogA)
   470  				if err := _EmitLog.contract.UnpackLog(event, "LogA", log); err != nil {
   471  					return err
   472  				}
   473  				event.Raw = log
   474  
   475  				select {
   476  				case sink <- event:
   477  				case err := <-sub.Err():
   478  					return err
   479  				case <-quit:
   480  					return nil
   481  				}
   482  			case err := <-sub.Err():
   483  				return err
   484  			case <-quit:
   485  				return nil
   486  			}
   487  		}
   488  	}), nil
   489  }
   490  
   491  // ParseLogA is a log parse operation binding the contract event 0x977224b24e70d33f3be87246a29c5636cfc8dd6853e175b54af01ff493ffac62.
   492  //
   493  // Solidity: event LogA(uint256 indexed a)
   494  func (_EmitLog *EmitLogFilterer) ParseLogA(log types.Log) (*EmitLogLogA, error) {
   495  	event := new(EmitLogLogA)
   496  	if err := _EmitLog.contract.UnpackLog(event, "LogA", log); err != nil {
   497  		return nil, err
   498  	}
   499  	event.Raw = log
   500  	return event, nil
   501  }
   502  
   503  // EmitLogLogABIterator is returned from FilterLogAB and is used to iterate over the raw logs and unpacked data for LogAB events raised by the EmitLog contract.
   504  type EmitLogLogABIterator struct {
   505  	Event *EmitLogLogAB // Event containing the contract specifics and raw log
   506  
   507  	contract *bind.BoundContract // Generic contract to use for unpacking event data
   508  	event    string              // Event name to use for unpacking event data
   509  
   510  	logs chan types.Log        // Log channel receiving the found contract events
   511  	sub  ethereum.Subscription // Subscription for errors, completion and termination
   512  	done bool                  // Whether the subscription completed delivering logs
   513  	fail error                 // Occurred error to stop iteration
   514  }
   515  
   516  // Next advances the iterator to the subsequent event, returning whether there
   517  // are any more events found. In case of a retrieval or parsing error, false is
   518  // returned and Error() can be queried for the exact failure.
   519  func (it *EmitLogLogABIterator) Next() bool {
   520  	// If the iterator failed, stop iterating
   521  	if it.fail != nil {
   522  		return false
   523  	}
   524  	// If the iterator completed, deliver directly whatever's available
   525  	if it.done {
   526  		select {
   527  		case log := <-it.logs:
   528  			it.Event = new(EmitLogLogAB)
   529  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   530  				it.fail = err
   531  				return false
   532  			}
   533  			it.Event.Raw = log
   534  			return true
   535  
   536  		default:
   537  			return false
   538  		}
   539  	}
   540  	// Iterator still in progress, wait for either a data or an error event
   541  	select {
   542  	case log := <-it.logs:
   543  		it.Event = new(EmitLogLogAB)
   544  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   545  			it.fail = err
   546  			return false
   547  		}
   548  		it.Event.Raw = log
   549  		return true
   550  
   551  	case err := <-it.sub.Err():
   552  		it.done = true
   553  		it.fail = err
   554  		return it.Next()
   555  	}
   556  }
   557  
   558  // Error returns any retrieval or parsing error occurred during filtering.
   559  func (it *EmitLogLogABIterator) Error() error {
   560  	return it.fail
   561  }
   562  
   563  // Close terminates the iteration process, releasing any pending underlying
   564  // resources.
   565  func (it *EmitLogLogABIterator) Close() error {
   566  	it.sub.Unsubscribe()
   567  	return nil
   568  }
   569  
   570  // EmitLogLogAB represents a LogAB event raised by the EmitLog contract.
   571  type EmitLogLogAB struct {
   572  	A   *big.Int
   573  	B   *big.Int
   574  	Raw types.Log // Blockchain specific contextual infos
   575  }
   576  
   577  // FilterLogAB is a free log retrieval operation binding the contract event 0xbb6e4da744abea70325874159d52c1ad3e57babfae7c329a948e7dcb274deb09.
   578  //
   579  // Solidity: event LogAB(uint256 indexed a, uint256 indexed b)
   580  func (_EmitLog *EmitLogFilterer) FilterLogAB(opts *bind.FilterOpts, a []*big.Int, b []*big.Int) (*EmitLogLogABIterator, error) {
   581  
   582  	var aRule []interface{}
   583  	for _, aItem := range a {
   584  		aRule = append(aRule, aItem)
   585  	}
   586  	var bRule []interface{}
   587  	for _, bItem := range b {
   588  		bRule = append(bRule, bItem)
   589  	}
   590  
   591  	logs, sub, err := _EmitLog.contract.FilterLogs(opts, "LogAB", aRule, bRule)
   592  	if err != nil {
   593  		return nil, err
   594  	}
   595  	return &EmitLogLogABIterator{contract: _EmitLog.contract, event: "LogAB", logs: logs, sub: sub}, nil
   596  }
   597  
   598  // WatchLogAB is a free log subscription operation binding the contract event 0xbb6e4da744abea70325874159d52c1ad3e57babfae7c329a948e7dcb274deb09.
   599  //
   600  // Solidity: event LogAB(uint256 indexed a, uint256 indexed b)
   601  func (_EmitLog *EmitLogFilterer) WatchLogAB(opts *bind.WatchOpts, sink chan<- *EmitLogLogAB, a []*big.Int, b []*big.Int) (event.Subscription, error) {
   602  
   603  	var aRule []interface{}
   604  	for _, aItem := range a {
   605  		aRule = append(aRule, aItem)
   606  	}
   607  	var bRule []interface{}
   608  	for _, bItem := range b {
   609  		bRule = append(bRule, bItem)
   610  	}
   611  
   612  	logs, sub, err := _EmitLog.contract.WatchLogs(opts, "LogAB", aRule, bRule)
   613  	if err != nil {
   614  		return nil, err
   615  	}
   616  	return event.NewSubscription(func(quit <-chan struct{}) error {
   617  		defer sub.Unsubscribe()
   618  		for {
   619  			select {
   620  			case log := <-logs:
   621  				// New log arrived, parse the event and forward to the user
   622  				event := new(EmitLogLogAB)
   623  				if err := _EmitLog.contract.UnpackLog(event, "LogAB", log); err != nil {
   624  					return err
   625  				}
   626  				event.Raw = log
   627  
   628  				select {
   629  				case sink <- event:
   630  				case err := <-sub.Err():
   631  					return err
   632  				case <-quit:
   633  					return nil
   634  				}
   635  			case err := <-sub.Err():
   636  				return err
   637  			case <-quit:
   638  				return nil
   639  			}
   640  		}
   641  	}), nil
   642  }
   643  
   644  // ParseLogAB is a log parse operation binding the contract event 0xbb6e4da744abea70325874159d52c1ad3e57babfae7c329a948e7dcb274deb09.
   645  //
   646  // Solidity: event LogAB(uint256 indexed a, uint256 indexed b)
   647  func (_EmitLog *EmitLogFilterer) ParseLogAB(log types.Log) (*EmitLogLogAB, error) {
   648  	event := new(EmitLogLogAB)
   649  	if err := _EmitLog.contract.UnpackLog(event, "LogAB", log); err != nil {
   650  		return nil, err
   651  	}
   652  	event.Raw = log
   653  	return event, nil
   654  }
   655  
   656  // EmitLogLogABCIterator is returned from FilterLogABC and is used to iterate over the raw logs and unpacked data for LogABC events raised by the EmitLog contract.
   657  type EmitLogLogABCIterator struct {
   658  	Event *EmitLogLogABC // Event containing the contract specifics and raw log
   659  
   660  	contract *bind.BoundContract // Generic contract to use for unpacking event data
   661  	event    string              // Event name to use for unpacking event data
   662  
   663  	logs chan types.Log        // Log channel receiving the found contract events
   664  	sub  ethereum.Subscription // Subscription for errors, completion and termination
   665  	done bool                  // Whether the subscription completed delivering logs
   666  	fail error                 // Occurred error to stop iteration
   667  }
   668  
   669  // Next advances the iterator to the subsequent event, returning whether there
   670  // are any more events found. In case of a retrieval or parsing error, false is
   671  // returned and Error() can be queried for the exact failure.
   672  func (it *EmitLogLogABCIterator) Next() bool {
   673  	// If the iterator failed, stop iterating
   674  	if it.fail != nil {
   675  		return false
   676  	}
   677  	// If the iterator completed, deliver directly whatever's available
   678  	if it.done {
   679  		select {
   680  		case log := <-it.logs:
   681  			it.Event = new(EmitLogLogABC)
   682  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   683  				it.fail = err
   684  				return false
   685  			}
   686  			it.Event.Raw = log
   687  			return true
   688  
   689  		default:
   690  			return false
   691  		}
   692  	}
   693  	// Iterator still in progress, wait for either a data or an error event
   694  	select {
   695  	case log := <-it.logs:
   696  		it.Event = new(EmitLogLogABC)
   697  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   698  			it.fail = err
   699  			return false
   700  		}
   701  		it.Event.Raw = log
   702  		return true
   703  
   704  	case err := <-it.sub.Err():
   705  		it.done = true
   706  		it.fail = err
   707  		return it.Next()
   708  	}
   709  }
   710  
   711  // Error returns any retrieval or parsing error occurred during filtering.
   712  func (it *EmitLogLogABCIterator) Error() error {
   713  	return it.fail
   714  }
   715  
   716  // Close terminates the iteration process, releasing any pending underlying
   717  // resources.
   718  func (it *EmitLogLogABCIterator) Close() error {
   719  	it.sub.Unsubscribe()
   720  	return nil
   721  }
   722  
   723  // EmitLogLogABC represents a LogABC event raised by the EmitLog contract.
   724  type EmitLogLogABC struct {
   725  	A   *big.Int
   726  	B   *big.Int
   727  	C   *big.Int
   728  	Raw types.Log // Blockchain specific contextual infos
   729  }
   730  
   731  // FilterLogABC is a free log retrieval operation binding the contract event 0x966018f1afaee50c6bcf5eb4ae089eeb650bd1deb473395d69dd307ef2e689b7.
   732  //
   733  // Solidity: event LogABC(uint256 indexed a, uint256 indexed b, uint256 indexed c)
   734  func (_EmitLog *EmitLogFilterer) FilterLogABC(opts *bind.FilterOpts, a []*big.Int, b []*big.Int, c []*big.Int) (*EmitLogLogABCIterator, error) {
   735  
   736  	var aRule []interface{}
   737  	for _, aItem := range a {
   738  		aRule = append(aRule, aItem)
   739  	}
   740  	var bRule []interface{}
   741  	for _, bItem := range b {
   742  		bRule = append(bRule, bItem)
   743  	}
   744  	var cRule []interface{}
   745  	for _, cItem := range c {
   746  		cRule = append(cRule, cItem)
   747  	}
   748  
   749  	logs, sub, err := _EmitLog.contract.FilterLogs(opts, "LogABC", aRule, bRule, cRule)
   750  	if err != nil {
   751  		return nil, err
   752  	}
   753  	return &EmitLogLogABCIterator{contract: _EmitLog.contract, event: "LogABC", logs: logs, sub: sub}, nil
   754  }
   755  
   756  // WatchLogABC is a free log subscription operation binding the contract event 0x966018f1afaee50c6bcf5eb4ae089eeb650bd1deb473395d69dd307ef2e689b7.
   757  //
   758  // Solidity: event LogABC(uint256 indexed a, uint256 indexed b, uint256 indexed c)
   759  func (_EmitLog *EmitLogFilterer) WatchLogABC(opts *bind.WatchOpts, sink chan<- *EmitLogLogABC, a []*big.Int, b []*big.Int, c []*big.Int) (event.Subscription, error) {
   760  
   761  	var aRule []interface{}
   762  	for _, aItem := range a {
   763  		aRule = append(aRule, aItem)
   764  	}
   765  	var bRule []interface{}
   766  	for _, bItem := range b {
   767  		bRule = append(bRule, bItem)
   768  	}
   769  	var cRule []interface{}
   770  	for _, cItem := range c {
   771  		cRule = append(cRule, cItem)
   772  	}
   773  
   774  	logs, sub, err := _EmitLog.contract.WatchLogs(opts, "LogABC", aRule, bRule, cRule)
   775  	if err != nil {
   776  		return nil, err
   777  	}
   778  	return event.NewSubscription(func(quit <-chan struct{}) error {
   779  		defer sub.Unsubscribe()
   780  		for {
   781  			select {
   782  			case log := <-logs:
   783  				// New log arrived, parse the event and forward to the user
   784  				event := new(EmitLogLogABC)
   785  				if err := _EmitLog.contract.UnpackLog(event, "LogABC", log); err != nil {
   786  					return err
   787  				}
   788  				event.Raw = log
   789  
   790  				select {
   791  				case sink <- event:
   792  				case err := <-sub.Err():
   793  					return err
   794  				case <-quit:
   795  					return nil
   796  				}
   797  			case err := <-sub.Err():
   798  				return err
   799  			case <-quit:
   800  				return nil
   801  			}
   802  		}
   803  	}), nil
   804  }
   805  
   806  // ParseLogABC is a log parse operation binding the contract event 0x966018f1afaee50c6bcf5eb4ae089eeb650bd1deb473395d69dd307ef2e689b7.
   807  //
   808  // Solidity: event LogABC(uint256 indexed a, uint256 indexed b, uint256 indexed c)
   809  func (_EmitLog *EmitLogFilterer) ParseLogABC(log types.Log) (*EmitLogLogABC, error) {
   810  	event := new(EmitLogLogABC)
   811  	if err := _EmitLog.contract.UnpackLog(event, "LogABC", log); err != nil {
   812  		return nil, err
   813  	}
   814  	event.Raw = log
   815  	return event, nil
   816  }
   817  
   818  // EmitLogLogABCDIterator is returned from FilterLogABCD and is used to iterate over the raw logs and unpacked data for LogABCD events raised by the EmitLog contract.
   819  type EmitLogLogABCDIterator struct {
   820  	Event *EmitLogLogABCD // Event containing the contract specifics and raw log
   821  
   822  	contract *bind.BoundContract // Generic contract to use for unpacking event data
   823  	event    string              // Event name to use for unpacking event data
   824  
   825  	logs chan types.Log        // Log channel receiving the found contract events
   826  	sub  ethereum.Subscription // Subscription for errors, completion and termination
   827  	done bool                  // Whether the subscription completed delivering logs
   828  	fail error                 // Occurred error to stop iteration
   829  }
   830  
   831  // Next advances the iterator to the subsequent event, returning whether there
   832  // are any more events found. In case of a retrieval or parsing error, false is
   833  // returned and Error() can be queried for the exact failure.
   834  func (it *EmitLogLogABCDIterator) Next() bool {
   835  	// If the iterator failed, stop iterating
   836  	if it.fail != nil {
   837  		return false
   838  	}
   839  	// If the iterator completed, deliver directly whatever's available
   840  	if it.done {
   841  		select {
   842  		case log := <-it.logs:
   843  			it.Event = new(EmitLogLogABCD)
   844  			if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   845  				it.fail = err
   846  				return false
   847  			}
   848  			it.Event.Raw = log
   849  			return true
   850  
   851  		default:
   852  			return false
   853  		}
   854  	}
   855  	// Iterator still in progress, wait for either a data or an error event
   856  	select {
   857  	case log := <-it.logs:
   858  		it.Event = new(EmitLogLogABCD)
   859  		if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil {
   860  			it.fail = err
   861  			return false
   862  		}
   863  		it.Event.Raw = log
   864  		return true
   865  
   866  	case err := <-it.sub.Err():
   867  		it.done = true
   868  		it.fail = err
   869  		return it.Next()
   870  	}
   871  }
   872  
   873  // Error returns any retrieval or parsing error occurred during filtering.
   874  func (it *EmitLogLogABCDIterator) Error() error {
   875  	return it.fail
   876  }
   877  
   878  // Close terminates the iteration process, releasing any pending underlying
   879  // resources.
   880  func (it *EmitLogLogABCDIterator) Close() error {
   881  	it.sub.Unsubscribe()
   882  	return nil
   883  }
   884  
   885  // EmitLogLogABCD represents a LogABCD event raised by the EmitLog contract.
   886  type EmitLogLogABCD struct {
   887  	A   *big.Int
   888  	B   *big.Int
   889  	C   *big.Int
   890  	D   *big.Int
   891  	Raw types.Log // Blockchain specific contextual infos
   892  }
   893  
   894  // FilterLogABCD is a free log retrieval operation binding the contract event 0xe5562b12d9276c5c987df08afff7b1946f2d869236866ea2285c7e2e95685a64.
   895  //
   896  // Solidity: event LogABCD(uint256 indexed a, uint256 indexed b, uint256 indexed c, uint256 d)
   897  func (_EmitLog *EmitLogFilterer) FilterLogABCD(opts *bind.FilterOpts, a []*big.Int, b []*big.Int, c []*big.Int) (*EmitLogLogABCDIterator, error) {
   898  
   899  	var aRule []interface{}
   900  	for _, aItem := range a {
   901  		aRule = append(aRule, aItem)
   902  	}
   903  	var bRule []interface{}
   904  	for _, bItem := range b {
   905  		bRule = append(bRule, bItem)
   906  	}
   907  	var cRule []interface{}
   908  	for _, cItem := range c {
   909  		cRule = append(cRule, cItem)
   910  	}
   911  
   912  	logs, sub, err := _EmitLog.contract.FilterLogs(opts, "LogABCD", aRule, bRule, cRule)
   913  	if err != nil {
   914  		return nil, err
   915  	}
   916  	return &EmitLogLogABCDIterator{contract: _EmitLog.contract, event: "LogABCD", logs: logs, sub: sub}, nil
   917  }
   918  
   919  // WatchLogABCD is a free log subscription operation binding the contract event 0xe5562b12d9276c5c987df08afff7b1946f2d869236866ea2285c7e2e95685a64.
   920  //
   921  // Solidity: event LogABCD(uint256 indexed a, uint256 indexed b, uint256 indexed c, uint256 d)
   922  func (_EmitLog *EmitLogFilterer) WatchLogABCD(opts *bind.WatchOpts, sink chan<- *EmitLogLogABCD, a []*big.Int, b []*big.Int, c []*big.Int) (event.Subscription, error) {
   923  
   924  	var aRule []interface{}
   925  	for _, aItem := range a {
   926  		aRule = append(aRule, aItem)
   927  	}
   928  	var bRule []interface{}
   929  	for _, bItem := range b {
   930  		bRule = append(bRule, bItem)
   931  	}
   932  	var cRule []interface{}
   933  	for _, cItem := range c {
   934  		cRule = append(cRule, cItem)
   935  	}
   936  
   937  	logs, sub, err := _EmitLog.contract.WatchLogs(opts, "LogABCD", aRule, bRule, cRule)
   938  	if err != nil {
   939  		return nil, err
   940  	}
   941  	return event.NewSubscription(func(quit <-chan struct{}) error {
   942  		defer sub.Unsubscribe()
   943  		for {
   944  			select {
   945  			case log := <-logs:
   946  				// New log arrived, parse the event and forward to the user
   947  				event := new(EmitLogLogABCD)
   948  				if err := _EmitLog.contract.UnpackLog(event, "LogABCD", log); err != nil {
   949  					return err
   950  				}
   951  				event.Raw = log
   952  
   953  				select {
   954  				case sink <- event:
   955  				case err := <-sub.Err():
   956  					return err
   957  				case <-quit:
   958  					return nil
   959  				}
   960  			case err := <-sub.Err():
   961  				return err
   962  			case <-quit:
   963  				return nil
   964  			}
   965  		}
   966  	}), nil
   967  }
   968  
   969  // ParseLogABCD is a log parse operation binding the contract event 0xe5562b12d9276c5c987df08afff7b1946f2d869236866ea2285c7e2e95685a64.
   970  //
   971  // Solidity: event LogABCD(uint256 indexed a, uint256 indexed b, uint256 indexed c, uint256 d)
   972  func (_EmitLog *EmitLogFilterer) ParseLogABCD(log types.Log) (*EmitLogLogABCD, error) {
   973  	event := new(EmitLogLogABCD)
   974  	if err := _EmitLog.contract.UnpackLog(event, "LogABCD", log); err != nil {
   975  		return nil, err
   976  	}
   977  	event.Raw = log
   978  	return event, nil
   979  }