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 }