github.com/Onther-Tech/plasma-evm@v0.0.0-rc7.7/contracts/plasma/token/token.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 token 5 6 import ( 7 "math/big" 8 "strings" 9 10 "github.com/Onther-Tech/plasma-evm" 11 "github.com/Onther-Tech/plasma-evm/accounts/abi" 12 "github.com/Onther-Tech/plasma-evm/accounts/abi/bind" 13 "github.com/Onther-Tech/plasma-evm/common" 14 "github.com/Onther-Tech/plasma-evm/core/types" 15 "github.com/Onther-Tech/plasma-evm/event" 16 ) 17 18 // Reference imports to suppress errors if they are not otherwise used. 19 var ( 20 _ = big.NewInt 21 _ = strings.NewReader 22 _ = ethereum.NotFound 23 _ = abi.U256 24 _ = bind.Bind 25 _ = common.Big1 26 _ = types.BloomLookup 27 _ = event.NewSubscription 28 ) 29 30 // OwnableABI is the input ABI used to generate the binding from. 31 const OwnableABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 32 33 // OwnableFuncSigs maps the 4-byte function signature to its string representation. 34 var OwnableFuncSigs = map[string]string{ 35 "8f32d59b": "isOwner()", 36 "8da5cb5b": "owner()", 37 "715018a6": "renounceOwnership()", 38 "f2fde38b": "transferOwnership(address)", 39 } 40 41 // Ownable is an auto generated Go binding around an Ethereum contract. 42 type Ownable struct { 43 OwnableCaller // Read-only binding to the contract 44 OwnableTransactor // Write-only binding to the contract 45 OwnableFilterer // Log filterer for contract events 46 } 47 48 // OwnableCaller is an auto generated read-only Go binding around an Ethereum contract. 49 type OwnableCaller struct { 50 contract *bind.BoundContract // Generic contract wrapper for the low level calls 51 } 52 53 // OwnableTransactor is an auto generated write-only Go binding around an Ethereum contract. 54 type OwnableTransactor struct { 55 contract *bind.BoundContract // Generic contract wrapper for the low level calls 56 } 57 58 // OwnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 59 type OwnableFilterer struct { 60 contract *bind.BoundContract // Generic contract wrapper for the low level calls 61 } 62 63 // OwnableSession is an auto generated Go binding around an Ethereum contract, 64 // with pre-set call and transact options. 65 type OwnableSession struct { 66 Contract *Ownable // Generic contract binding to set the session for 67 CallOpts bind.CallOpts // Call options to use throughout this session 68 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 69 } 70 71 // OwnableCallerSession is an auto generated read-only Go binding around an Ethereum contract, 72 // with pre-set call options. 73 type OwnableCallerSession struct { 74 Contract *OwnableCaller // Generic contract caller binding to set the session for 75 CallOpts bind.CallOpts // Call options to use throughout this session 76 } 77 78 // OwnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 79 // with pre-set transact options. 80 type OwnableTransactorSession struct { 81 Contract *OwnableTransactor // Generic contract transactor binding to set the session for 82 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 83 } 84 85 // OwnableRaw is an auto generated low-level Go binding around an Ethereum contract. 86 type OwnableRaw struct { 87 Contract *Ownable // Generic contract binding to access the raw methods on 88 } 89 90 // OwnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 91 type OwnableCallerRaw struct { 92 Contract *OwnableCaller // Generic read-only contract binding to access the raw methods on 93 } 94 95 // OwnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 96 type OwnableTransactorRaw struct { 97 Contract *OwnableTransactor // Generic write-only contract binding to access the raw methods on 98 } 99 100 // NewOwnable creates a new instance of Ownable, bound to a specific deployed contract. 101 func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error) { 102 contract, err := bindOwnable(address, backend, backend, backend) 103 if err != nil { 104 return nil, err 105 } 106 return &Ownable{OwnableCaller: OwnableCaller{contract: contract}, OwnableTransactor: OwnableTransactor{contract: contract}, OwnableFilterer: OwnableFilterer{contract: contract}}, nil 107 } 108 109 // NewOwnableCaller creates a new read-only instance of Ownable, bound to a specific deployed contract. 110 func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error) { 111 contract, err := bindOwnable(address, caller, nil, nil) 112 if err != nil { 113 return nil, err 114 } 115 return &OwnableCaller{contract: contract}, nil 116 } 117 118 // NewOwnableTransactor creates a new write-only instance of Ownable, bound to a specific deployed contract. 119 func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error) { 120 contract, err := bindOwnable(address, nil, transactor, nil) 121 if err != nil { 122 return nil, err 123 } 124 return &OwnableTransactor{contract: contract}, nil 125 } 126 127 // NewOwnableFilterer creates a new log filterer instance of Ownable, bound to a specific deployed contract. 128 func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error) { 129 contract, err := bindOwnable(address, nil, nil, filterer) 130 if err != nil { 131 return nil, err 132 } 133 return &OwnableFilterer{contract: contract}, nil 134 } 135 136 // bindOwnable binds a generic wrapper to an already deployed contract. 137 func bindOwnable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 138 parsed, err := abi.JSON(strings.NewReader(OwnableABI)) 139 if err != nil { 140 return nil, err 141 } 142 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 143 } 144 145 // Call invokes the (constant) contract method with params as input values and 146 // sets the output to result. The result type might be a single field for simple 147 // returns, a slice of interfaces for anonymous returns and a struct for named 148 // returns. 149 func (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 150 return _Ownable.Contract.OwnableCaller.contract.Call(opts, result, method, params...) 151 } 152 153 // Transfer initiates a plain transaction to move funds to the contract, calling 154 // its default method if one is available. 155 func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 156 return _Ownable.Contract.OwnableTransactor.contract.Transfer(opts) 157 } 158 159 // Transact invokes the (paid) contract method with params as input values. 160 func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 161 return _Ownable.Contract.OwnableTransactor.contract.Transact(opts, method, params...) 162 } 163 164 // Call invokes the (constant) contract method with params as input values and 165 // sets the output to result. The result type might be a single field for simple 166 // returns, a slice of interfaces for anonymous returns and a struct for named 167 // returns. 168 func (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 169 return _Ownable.Contract.contract.Call(opts, result, method, params...) 170 } 171 172 // Transfer initiates a plain transaction to move funds to the contract, calling 173 // its default method if one is available. 174 func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 175 return _Ownable.Contract.contract.Transfer(opts) 176 } 177 178 // Transact invokes the (paid) contract method with params as input values. 179 func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 180 return _Ownable.Contract.contract.Transact(opts, method, params...) 181 } 182 183 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 184 // 185 // Solidity: function isOwner() constant returns(bool) 186 func (_Ownable *OwnableCaller) IsOwner(opts *bind.CallOpts) (bool, error) { 187 var ( 188 ret0 = new(bool) 189 ) 190 out := ret0 191 err := _Ownable.contract.Call(opts, out, "isOwner") 192 return *ret0, err 193 } 194 195 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 196 // 197 // Solidity: function isOwner() constant returns(bool) 198 func (_Ownable *OwnableSession) IsOwner() (bool, error) { 199 return _Ownable.Contract.IsOwner(&_Ownable.CallOpts) 200 } 201 202 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 203 // 204 // Solidity: function isOwner() constant returns(bool) 205 func (_Ownable *OwnableCallerSession) IsOwner() (bool, error) { 206 return _Ownable.Contract.IsOwner(&_Ownable.CallOpts) 207 } 208 209 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 210 // 211 // Solidity: function owner() constant returns(address) 212 func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 213 var ( 214 ret0 = new(common.Address) 215 ) 216 out := ret0 217 err := _Ownable.contract.Call(opts, out, "owner") 218 return *ret0, err 219 } 220 221 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 222 // 223 // Solidity: function owner() constant returns(address) 224 func (_Ownable *OwnableSession) Owner() (common.Address, error) { 225 return _Ownable.Contract.Owner(&_Ownable.CallOpts) 226 } 227 228 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 229 // 230 // Solidity: function owner() constant returns(address) 231 func (_Ownable *OwnableCallerSession) Owner() (common.Address, error) { 232 return _Ownable.Contract.Owner(&_Ownable.CallOpts) 233 } 234 235 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 236 // 237 // Solidity: function renounceOwnership() returns() 238 func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { 239 return _Ownable.contract.Transact(opts, "renounceOwnership") 240 } 241 242 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 243 // 244 // Solidity: function renounceOwnership() returns() 245 func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error) { 246 return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts) 247 } 248 249 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 250 // 251 // Solidity: function renounceOwnership() returns() 252 func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error) { 253 return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts) 254 } 255 256 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 257 // 258 // Solidity: function transferOwnership(address newOwner) returns() 259 func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 260 return _Ownable.contract.Transact(opts, "transferOwnership", newOwner) 261 } 262 263 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 264 // 265 // Solidity: function transferOwnership(address newOwner) returns() 266 func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 267 return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner) 268 } 269 270 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 271 // 272 // Solidity: function transferOwnership(address newOwner) returns() 273 func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 274 return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner) 275 } 276 277 // OwnableOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the Ownable contract. 278 type OwnableOwnershipTransferredIterator struct { 279 Event *OwnableOwnershipTransferred // Event containing the contract specifics and raw log 280 281 contract *bind.BoundContract // Generic contract to use for unpacking event data 282 event string // Event name to use for unpacking event data 283 284 logs chan types.Log // Log channel receiving the found contract events 285 sub ethereum.Subscription // Subscription for errors, completion and termination 286 done bool // Whether the subscription completed delivering logs 287 fail error // Occurred error to stop iteration 288 } 289 290 // Next advances the iterator to the subsequent event, returning whether there 291 // are any more events found. In case of a retrieval or parsing error, false is 292 // returned and Error() can be queried for the exact failure. 293 func (it *OwnableOwnershipTransferredIterator) Next() bool { 294 // If the iterator failed, stop iterating 295 if it.fail != nil { 296 return false 297 } 298 // If the iterator completed, deliver directly whatever's available 299 if it.done { 300 select { 301 case log := <-it.logs: 302 it.Event = new(OwnableOwnershipTransferred) 303 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 304 it.fail = err 305 return false 306 } 307 it.Event.Raw = log 308 return true 309 310 default: 311 return false 312 } 313 } 314 // Iterator still in progress, wait for either a data or an error event 315 select { 316 case log := <-it.logs: 317 it.Event = new(OwnableOwnershipTransferred) 318 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 319 it.fail = err 320 return false 321 } 322 it.Event.Raw = log 323 return true 324 325 case err := <-it.sub.Err(): 326 it.done = true 327 it.fail = err 328 return it.Next() 329 } 330 } 331 332 // Error returns any retrieval or parsing error occurred during filtering. 333 func (it *OwnableOwnershipTransferredIterator) Error() error { 334 return it.fail 335 } 336 337 // Close terminates the iteration process, releasing any pending underlying 338 // resources. 339 func (it *OwnableOwnershipTransferredIterator) Close() error { 340 it.sub.Unsubscribe() 341 return nil 342 } 343 344 // OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract. 345 type OwnableOwnershipTransferred struct { 346 PreviousOwner common.Address 347 NewOwner common.Address 348 Raw types.Log // Blockchain specific contextual infos 349 } 350 351 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 352 // 353 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 354 func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OwnableOwnershipTransferredIterator, error) { 355 356 var previousOwnerRule []interface{} 357 for _, previousOwnerItem := range previousOwner { 358 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 359 } 360 var newOwnerRule []interface{} 361 for _, newOwnerItem := range newOwner { 362 newOwnerRule = append(newOwnerRule, newOwnerItem) 363 } 364 365 logs, sub, err := _Ownable.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 366 if err != nil { 367 return nil, err 368 } 369 return &OwnableOwnershipTransferredIterator{contract: _Ownable.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 370 } 371 372 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 373 // 374 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 375 func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 376 377 var previousOwnerRule []interface{} 378 for _, previousOwnerItem := range previousOwner { 379 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 380 } 381 var newOwnerRule []interface{} 382 for _, newOwnerItem := range newOwner { 383 newOwnerRule = append(newOwnerRule, newOwnerItem) 384 } 385 386 logs, sub, err := _Ownable.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 387 if err != nil { 388 return nil, err 389 } 390 return event.NewSubscription(func(quit <-chan struct{}) error { 391 defer sub.Unsubscribe() 392 for { 393 select { 394 case log := <-logs: 395 // New log arrived, parse the event and forward to the user 396 event := new(OwnableOwnershipTransferred) 397 if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 398 return err 399 } 400 event.Raw = log 401 402 select { 403 case sink <- event: 404 case err := <-sub.Err(): 405 return err 406 case <-quit: 407 return nil 408 } 409 case err := <-sub.Err(): 410 return err 411 case <-quit: 412 return nil 413 } 414 } 415 }), nil 416 } 417 418 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 419 // 420 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 421 func (_Ownable *OwnableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableOwnershipTransferred, error) { 422 event := new(OwnableOwnershipTransferred) 423 if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 424 return nil, err 425 } 426 return event, nil 427 } 428 429 // RequestableIABI is the input ABI used to generate the binding from. 430 const RequestableIABI = "[{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"isExit\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"requestId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"requestor\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"trieKey\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"trieValue\",\"type\":\"bytes\"}],\"name\":\"applyRequestInChildChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"isExit\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"requestId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"requestor\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"trieKey\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"trieValue\",\"type\":\"bytes\"}],\"name\":\"applyRequestInRootChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 431 432 // RequestableIFuncSigs maps the 4-byte function signature to its string representation. 433 var RequestableIFuncSigs = map[string]string{ 434 "141ecf46": "applyRequestInChildChain(bool,uint256,address,bytes32,bytes)", 435 "a9f79308": "applyRequestInRootChain(bool,uint256,address,bytes32,bytes)", 436 } 437 438 // RequestableI is an auto generated Go binding around an Ethereum contract. 439 type RequestableI struct { 440 RequestableICaller // Read-only binding to the contract 441 RequestableITransactor // Write-only binding to the contract 442 RequestableIFilterer // Log filterer for contract events 443 } 444 445 // RequestableICaller is an auto generated read-only Go binding around an Ethereum contract. 446 type RequestableICaller struct { 447 contract *bind.BoundContract // Generic contract wrapper for the low level calls 448 } 449 450 // RequestableITransactor is an auto generated write-only Go binding around an Ethereum contract. 451 type RequestableITransactor struct { 452 contract *bind.BoundContract // Generic contract wrapper for the low level calls 453 } 454 455 // RequestableIFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 456 type RequestableIFilterer struct { 457 contract *bind.BoundContract // Generic contract wrapper for the low level calls 458 } 459 460 // RequestableISession is an auto generated Go binding around an Ethereum contract, 461 // with pre-set call and transact options. 462 type RequestableISession struct { 463 Contract *RequestableI // Generic contract binding to set the session for 464 CallOpts bind.CallOpts // Call options to use throughout this session 465 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 466 } 467 468 // RequestableICallerSession is an auto generated read-only Go binding around an Ethereum contract, 469 // with pre-set call options. 470 type RequestableICallerSession struct { 471 Contract *RequestableICaller // Generic contract caller binding to set the session for 472 CallOpts bind.CallOpts // Call options to use throughout this session 473 } 474 475 // RequestableITransactorSession is an auto generated write-only Go binding around an Ethereum contract, 476 // with pre-set transact options. 477 type RequestableITransactorSession struct { 478 Contract *RequestableITransactor // Generic contract transactor binding to set the session for 479 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 480 } 481 482 // RequestableIRaw is an auto generated low-level Go binding around an Ethereum contract. 483 type RequestableIRaw struct { 484 Contract *RequestableI // Generic contract binding to access the raw methods on 485 } 486 487 // RequestableICallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 488 type RequestableICallerRaw struct { 489 Contract *RequestableICaller // Generic read-only contract binding to access the raw methods on 490 } 491 492 // RequestableITransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 493 type RequestableITransactorRaw struct { 494 Contract *RequestableITransactor // Generic write-only contract binding to access the raw methods on 495 } 496 497 // NewRequestableI creates a new instance of RequestableI, bound to a specific deployed contract. 498 func NewRequestableI(address common.Address, backend bind.ContractBackend) (*RequestableI, error) { 499 contract, err := bindRequestableI(address, backend, backend, backend) 500 if err != nil { 501 return nil, err 502 } 503 return &RequestableI{RequestableICaller: RequestableICaller{contract: contract}, RequestableITransactor: RequestableITransactor{contract: contract}, RequestableIFilterer: RequestableIFilterer{contract: contract}}, nil 504 } 505 506 // NewRequestableICaller creates a new read-only instance of RequestableI, bound to a specific deployed contract. 507 func NewRequestableICaller(address common.Address, caller bind.ContractCaller) (*RequestableICaller, error) { 508 contract, err := bindRequestableI(address, caller, nil, nil) 509 if err != nil { 510 return nil, err 511 } 512 return &RequestableICaller{contract: contract}, nil 513 } 514 515 // NewRequestableITransactor creates a new write-only instance of RequestableI, bound to a specific deployed contract. 516 func NewRequestableITransactor(address common.Address, transactor bind.ContractTransactor) (*RequestableITransactor, error) { 517 contract, err := bindRequestableI(address, nil, transactor, nil) 518 if err != nil { 519 return nil, err 520 } 521 return &RequestableITransactor{contract: contract}, nil 522 } 523 524 // NewRequestableIFilterer creates a new log filterer instance of RequestableI, bound to a specific deployed contract. 525 func NewRequestableIFilterer(address common.Address, filterer bind.ContractFilterer) (*RequestableIFilterer, error) { 526 contract, err := bindRequestableI(address, nil, nil, filterer) 527 if err != nil { 528 return nil, err 529 } 530 return &RequestableIFilterer{contract: contract}, nil 531 } 532 533 // bindRequestableI binds a generic wrapper to an already deployed contract. 534 func bindRequestableI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 535 parsed, err := abi.JSON(strings.NewReader(RequestableIABI)) 536 if err != nil { 537 return nil, err 538 } 539 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 540 } 541 542 // Call invokes the (constant) contract method with params as input values and 543 // sets the output to result. The result type might be a single field for simple 544 // returns, a slice of interfaces for anonymous returns and a struct for named 545 // returns. 546 func (_RequestableI *RequestableIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 547 return _RequestableI.Contract.RequestableICaller.contract.Call(opts, result, method, params...) 548 } 549 550 // Transfer initiates a plain transaction to move funds to the contract, calling 551 // its default method if one is available. 552 func (_RequestableI *RequestableIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 553 return _RequestableI.Contract.RequestableITransactor.contract.Transfer(opts) 554 } 555 556 // Transact invokes the (paid) contract method with params as input values. 557 func (_RequestableI *RequestableIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 558 return _RequestableI.Contract.RequestableITransactor.contract.Transact(opts, method, params...) 559 } 560 561 // Call invokes the (constant) contract method with params as input values and 562 // sets the output to result. The result type might be a single field for simple 563 // returns, a slice of interfaces for anonymous returns and a struct for named 564 // returns. 565 func (_RequestableI *RequestableICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 566 return _RequestableI.Contract.contract.Call(opts, result, method, params...) 567 } 568 569 // Transfer initiates a plain transaction to move funds to the contract, calling 570 // its default method if one is available. 571 func (_RequestableI *RequestableITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 572 return _RequestableI.Contract.contract.Transfer(opts) 573 } 574 575 // Transact invokes the (paid) contract method with params as input values. 576 func (_RequestableI *RequestableITransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 577 return _RequestableI.Contract.contract.Transact(opts, method, params...) 578 } 579 580 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 581 // 582 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 583 func (_RequestableI *RequestableITransactor) ApplyRequestInChildChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 584 return _RequestableI.contract.Transact(opts, "applyRequestInChildChain", isExit, requestId, requestor, trieKey, trieValue) 585 } 586 587 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 588 // 589 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 590 func (_RequestableI *RequestableISession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 591 return _RequestableI.Contract.ApplyRequestInChildChain(&_RequestableI.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 592 } 593 594 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 595 // 596 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 597 func (_RequestableI *RequestableITransactorSession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 598 return _RequestableI.Contract.ApplyRequestInChildChain(&_RequestableI.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 599 } 600 601 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 602 // 603 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 604 func (_RequestableI *RequestableITransactor) ApplyRequestInRootChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 605 return _RequestableI.contract.Transact(opts, "applyRequestInRootChain", isExit, requestId, requestor, trieKey, trieValue) 606 } 607 608 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 609 // 610 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 611 func (_RequestableI *RequestableISession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 612 return _RequestableI.Contract.ApplyRequestInRootChain(&_RequestableI.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 613 } 614 615 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 616 // 617 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 618 func (_RequestableI *RequestableITransactorSession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 619 return _RequestableI.Contract.ApplyRequestInRootChain(&_RequestableI.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 620 } 621 622 // RequestableSimpleTokenABI is the input ABI used to generate the binding from. 623 const RequestableSimpleTokenABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"Mint\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"previousOwner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"OwnershipTransferred\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"bool\",\"name\":\"_isExit\",\"type\":\"bool\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_requestor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"bytes32\",\"name\":\"_trieKey\",\"type\":\"bytes32\"},{\"indexed\":false,\"internalType\":\"bytes\",\"name\":\"_trieValue\",\"type\":\"bytes\"}],\"name\":\"Requested\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_from\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"KEY_OWNER\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"KEY_TOTAL_SUPPLY\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"PERFIX_BALANCES\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"isExit\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"requestId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"requestor\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"trieKey\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"trieValue\",\"type\":\"bytes\"}],\"name\":\"applyRequestInChildChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"bool\",\"name\":\"isExit\",\"type\":\"bool\"},{\"internalType\":\"uint256\",\"name\":\"requestId\",\"type\":\"uint256\"},{\"internalType\":\"address\",\"name\":\"requestor\",\"type\":\"address\"},{\"internalType\":\"bytes32\",\"name\":\"trieKey\",\"type\":\"bytes32\"},{\"internalType\":\"bytes\",\"name\":\"trieValue\",\"type\":\"bytes\"}],\"name\":\"applyRequestInRootChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"success\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"name\":\"balances\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"bytes\",\"name\":\"trieValue\",\"type\":\"bytes\"}],\"name\":\"decodeTrieValue\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"v\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"who\",\"type\":\"address\"}],\"name\":\"getBalanceTrieKey\",\"outputs\":[{\"internalType\":\"bytes32\",\"name\":\"\",\"type\":\"bytes32\"}],\"payable\":false,\"stateMutability\":\"pure\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"totalSupply\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"_to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"_value\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 624 625 // RequestableSimpleTokenFuncSigs maps the 4-byte function signature to its string representation. 626 var RequestableSimpleTokenFuncSigs = map[string]string{ 627 "f904d9eb": "KEY_OWNER()", 628 "cb069663": "KEY_TOTAL_SUPPLY()", 629 "a8490815": "PERFIX_BALANCES()", 630 "141ecf46": "applyRequestInChildChain(bool,uint256,address,bytes32,bytes)", 631 "a9f79308": "applyRequestInRootChain(bool,uint256,address,bytes32,bytes)", 632 "27e235e3": "balances(address)", 633 "b9e59d09": "decodeTrieValue(bytes)", 634 "b18fcfdf": "getBalanceTrieKey(address)", 635 "8f32d59b": "isOwner()", 636 "40c10f19": "mint(address,uint256)", 637 "8da5cb5b": "owner()", 638 "715018a6": "renounceOwnership()", 639 "18160ddd": "totalSupply()", 640 "a9059cbb": "transfer(address,uint256)", 641 "f2fde38b": "transferOwnership(address)", 642 } 643 644 // RequestableSimpleTokenBin is the compiled bytecode used for deploying new contracts. 645 var RequestableSimpleTokenBin = "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" 646 647 // DeployRequestableSimpleToken deploys a new Ethereum contract, binding an instance of RequestableSimpleToken to it. 648 func DeployRequestableSimpleToken(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *RequestableSimpleToken, error) { 649 parsed, err := abi.JSON(strings.NewReader(RequestableSimpleTokenABI)) 650 if err != nil { 651 return common.Address{}, nil, nil, err 652 } 653 654 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(RequestableSimpleTokenBin), backend) 655 if err != nil { 656 return common.Address{}, nil, nil, err 657 } 658 return address, tx, &RequestableSimpleToken{RequestableSimpleTokenCaller: RequestableSimpleTokenCaller{contract: contract}, RequestableSimpleTokenTransactor: RequestableSimpleTokenTransactor{contract: contract}, RequestableSimpleTokenFilterer: RequestableSimpleTokenFilterer{contract: contract}}, nil 659 } 660 661 // RequestableSimpleToken is an auto generated Go binding around an Ethereum contract. 662 type RequestableSimpleToken struct { 663 RequestableSimpleTokenCaller // Read-only binding to the contract 664 RequestableSimpleTokenTransactor // Write-only binding to the contract 665 RequestableSimpleTokenFilterer // Log filterer for contract events 666 } 667 668 // RequestableSimpleTokenCaller is an auto generated read-only Go binding around an Ethereum contract. 669 type RequestableSimpleTokenCaller struct { 670 contract *bind.BoundContract // Generic contract wrapper for the low level calls 671 } 672 673 // RequestableSimpleTokenTransactor is an auto generated write-only Go binding around an Ethereum contract. 674 type RequestableSimpleTokenTransactor struct { 675 contract *bind.BoundContract // Generic contract wrapper for the low level calls 676 } 677 678 // RequestableSimpleTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 679 type RequestableSimpleTokenFilterer struct { 680 contract *bind.BoundContract // Generic contract wrapper for the low level calls 681 } 682 683 // RequestableSimpleTokenSession is an auto generated Go binding around an Ethereum contract, 684 // with pre-set call and transact options. 685 type RequestableSimpleTokenSession struct { 686 Contract *RequestableSimpleToken // Generic contract binding to set the session for 687 CallOpts bind.CallOpts // Call options to use throughout this session 688 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 689 } 690 691 // RequestableSimpleTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract, 692 // with pre-set call options. 693 type RequestableSimpleTokenCallerSession struct { 694 Contract *RequestableSimpleTokenCaller // Generic contract caller binding to set the session for 695 CallOpts bind.CallOpts // Call options to use throughout this session 696 } 697 698 // RequestableSimpleTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 699 // with pre-set transact options. 700 type RequestableSimpleTokenTransactorSession struct { 701 Contract *RequestableSimpleTokenTransactor // Generic contract transactor binding to set the session for 702 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 703 } 704 705 // RequestableSimpleTokenRaw is an auto generated low-level Go binding around an Ethereum contract. 706 type RequestableSimpleTokenRaw struct { 707 Contract *RequestableSimpleToken // Generic contract binding to access the raw methods on 708 } 709 710 // RequestableSimpleTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 711 type RequestableSimpleTokenCallerRaw struct { 712 Contract *RequestableSimpleTokenCaller // Generic read-only contract binding to access the raw methods on 713 } 714 715 // RequestableSimpleTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 716 type RequestableSimpleTokenTransactorRaw struct { 717 Contract *RequestableSimpleTokenTransactor // Generic write-only contract binding to access the raw methods on 718 } 719 720 // NewRequestableSimpleToken creates a new instance of RequestableSimpleToken, bound to a specific deployed contract. 721 func NewRequestableSimpleToken(address common.Address, backend bind.ContractBackend) (*RequestableSimpleToken, error) { 722 contract, err := bindRequestableSimpleToken(address, backend, backend, backend) 723 if err != nil { 724 return nil, err 725 } 726 return &RequestableSimpleToken{RequestableSimpleTokenCaller: RequestableSimpleTokenCaller{contract: contract}, RequestableSimpleTokenTransactor: RequestableSimpleTokenTransactor{contract: contract}, RequestableSimpleTokenFilterer: RequestableSimpleTokenFilterer{contract: contract}}, nil 727 } 728 729 // NewRequestableSimpleTokenCaller creates a new read-only instance of RequestableSimpleToken, bound to a specific deployed contract. 730 func NewRequestableSimpleTokenCaller(address common.Address, caller bind.ContractCaller) (*RequestableSimpleTokenCaller, error) { 731 contract, err := bindRequestableSimpleToken(address, caller, nil, nil) 732 if err != nil { 733 return nil, err 734 } 735 return &RequestableSimpleTokenCaller{contract: contract}, nil 736 } 737 738 // NewRequestableSimpleTokenTransactor creates a new write-only instance of RequestableSimpleToken, bound to a specific deployed contract. 739 func NewRequestableSimpleTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*RequestableSimpleTokenTransactor, error) { 740 contract, err := bindRequestableSimpleToken(address, nil, transactor, nil) 741 if err != nil { 742 return nil, err 743 } 744 return &RequestableSimpleTokenTransactor{contract: contract}, nil 745 } 746 747 // NewRequestableSimpleTokenFilterer creates a new log filterer instance of RequestableSimpleToken, bound to a specific deployed contract. 748 func NewRequestableSimpleTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*RequestableSimpleTokenFilterer, error) { 749 contract, err := bindRequestableSimpleToken(address, nil, nil, filterer) 750 if err != nil { 751 return nil, err 752 } 753 return &RequestableSimpleTokenFilterer{contract: contract}, nil 754 } 755 756 // bindRequestableSimpleToken binds a generic wrapper to an already deployed contract. 757 func bindRequestableSimpleToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 758 parsed, err := abi.JSON(strings.NewReader(RequestableSimpleTokenABI)) 759 if err != nil { 760 return nil, err 761 } 762 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 763 } 764 765 // Call invokes the (constant) contract method with params as input values and 766 // sets the output to result. The result type might be a single field for simple 767 // returns, a slice of interfaces for anonymous returns and a struct for named 768 // returns. 769 func (_RequestableSimpleToken *RequestableSimpleTokenRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 770 return _RequestableSimpleToken.Contract.RequestableSimpleTokenCaller.contract.Call(opts, result, method, params...) 771 } 772 773 // Transfer initiates a plain transaction to move funds to the contract, calling 774 // its default method if one is available. 775 func (_RequestableSimpleToken *RequestableSimpleTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 776 return _RequestableSimpleToken.Contract.RequestableSimpleTokenTransactor.contract.Transfer(opts) 777 } 778 779 // Transact invokes the (paid) contract method with params as input values. 780 func (_RequestableSimpleToken *RequestableSimpleTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 781 return _RequestableSimpleToken.Contract.RequestableSimpleTokenTransactor.contract.Transact(opts, method, params...) 782 } 783 784 // Call invokes the (constant) contract method with params as input values and 785 // sets the output to result. The result type might be a single field for simple 786 // returns, a slice of interfaces for anonymous returns and a struct for named 787 // returns. 788 func (_RequestableSimpleToken *RequestableSimpleTokenCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 789 return _RequestableSimpleToken.Contract.contract.Call(opts, result, method, params...) 790 } 791 792 // Transfer initiates a plain transaction to move funds to the contract, calling 793 // its default method if one is available. 794 func (_RequestableSimpleToken *RequestableSimpleTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 795 return _RequestableSimpleToken.Contract.contract.Transfer(opts) 796 } 797 798 // Transact invokes the (paid) contract method with params as input values. 799 func (_RequestableSimpleToken *RequestableSimpleTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 800 return _RequestableSimpleToken.Contract.contract.Transact(opts, method, params...) 801 } 802 803 // KEYOWNER is a free data retrieval call binding the contract method 0xf904d9eb. 804 // 805 // Solidity: function KEY_OWNER() constant returns(bytes32) 806 func (_RequestableSimpleToken *RequestableSimpleTokenCaller) KEYOWNER(opts *bind.CallOpts) ([32]byte, error) { 807 var ( 808 ret0 = new([32]byte) 809 ) 810 out := ret0 811 err := _RequestableSimpleToken.contract.Call(opts, out, "KEY_OWNER") 812 return *ret0, err 813 } 814 815 // KEYOWNER is a free data retrieval call binding the contract method 0xf904d9eb. 816 // 817 // Solidity: function KEY_OWNER() constant returns(bytes32) 818 func (_RequestableSimpleToken *RequestableSimpleTokenSession) KEYOWNER() ([32]byte, error) { 819 return _RequestableSimpleToken.Contract.KEYOWNER(&_RequestableSimpleToken.CallOpts) 820 } 821 822 // KEYOWNER is a free data retrieval call binding the contract method 0xf904d9eb. 823 // 824 // Solidity: function KEY_OWNER() constant returns(bytes32) 825 func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) KEYOWNER() ([32]byte, error) { 826 return _RequestableSimpleToken.Contract.KEYOWNER(&_RequestableSimpleToken.CallOpts) 827 } 828 829 // KEYTOTALSUPPLY is a free data retrieval call binding the contract method 0xcb069663. 830 // 831 // Solidity: function KEY_TOTAL_SUPPLY() constant returns(bytes32) 832 func (_RequestableSimpleToken *RequestableSimpleTokenCaller) KEYTOTALSUPPLY(opts *bind.CallOpts) ([32]byte, error) { 833 var ( 834 ret0 = new([32]byte) 835 ) 836 out := ret0 837 err := _RequestableSimpleToken.contract.Call(opts, out, "KEY_TOTAL_SUPPLY") 838 return *ret0, err 839 } 840 841 // KEYTOTALSUPPLY is a free data retrieval call binding the contract method 0xcb069663. 842 // 843 // Solidity: function KEY_TOTAL_SUPPLY() constant returns(bytes32) 844 func (_RequestableSimpleToken *RequestableSimpleTokenSession) KEYTOTALSUPPLY() ([32]byte, error) { 845 return _RequestableSimpleToken.Contract.KEYTOTALSUPPLY(&_RequestableSimpleToken.CallOpts) 846 } 847 848 // KEYTOTALSUPPLY is a free data retrieval call binding the contract method 0xcb069663. 849 // 850 // Solidity: function KEY_TOTAL_SUPPLY() constant returns(bytes32) 851 func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) KEYTOTALSUPPLY() ([32]byte, error) { 852 return _RequestableSimpleToken.Contract.KEYTOTALSUPPLY(&_RequestableSimpleToken.CallOpts) 853 } 854 855 // PERFIXBALANCES is a free data retrieval call binding the contract method 0xa8490815. 856 // 857 // Solidity: function PERFIX_BALANCES() constant returns(bytes32) 858 func (_RequestableSimpleToken *RequestableSimpleTokenCaller) PERFIXBALANCES(opts *bind.CallOpts) ([32]byte, error) { 859 var ( 860 ret0 = new([32]byte) 861 ) 862 out := ret0 863 err := _RequestableSimpleToken.contract.Call(opts, out, "PERFIX_BALANCES") 864 return *ret0, err 865 } 866 867 // PERFIXBALANCES is a free data retrieval call binding the contract method 0xa8490815. 868 // 869 // Solidity: function PERFIX_BALANCES() constant returns(bytes32) 870 func (_RequestableSimpleToken *RequestableSimpleTokenSession) PERFIXBALANCES() ([32]byte, error) { 871 return _RequestableSimpleToken.Contract.PERFIXBALANCES(&_RequestableSimpleToken.CallOpts) 872 } 873 874 // PERFIXBALANCES is a free data retrieval call binding the contract method 0xa8490815. 875 // 876 // Solidity: function PERFIX_BALANCES() constant returns(bytes32) 877 func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) PERFIXBALANCES() ([32]byte, error) { 878 return _RequestableSimpleToken.Contract.PERFIXBALANCES(&_RequestableSimpleToken.CallOpts) 879 } 880 881 // Balances is a free data retrieval call binding the contract method 0x27e235e3. 882 // 883 // Solidity: function balances(address ) constant returns(uint256) 884 func (_RequestableSimpleToken *RequestableSimpleTokenCaller) Balances(opts *bind.CallOpts, arg0 common.Address) (*big.Int, error) { 885 var ( 886 ret0 = new(*big.Int) 887 ) 888 out := ret0 889 err := _RequestableSimpleToken.contract.Call(opts, out, "balances", arg0) 890 return *ret0, err 891 } 892 893 // Balances is a free data retrieval call binding the contract method 0x27e235e3. 894 // 895 // Solidity: function balances(address ) constant returns(uint256) 896 func (_RequestableSimpleToken *RequestableSimpleTokenSession) Balances(arg0 common.Address) (*big.Int, error) { 897 return _RequestableSimpleToken.Contract.Balances(&_RequestableSimpleToken.CallOpts, arg0) 898 } 899 900 // Balances is a free data retrieval call binding the contract method 0x27e235e3. 901 // 902 // Solidity: function balances(address ) constant returns(uint256) 903 func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) Balances(arg0 common.Address) (*big.Int, error) { 904 return _RequestableSimpleToken.Contract.Balances(&_RequestableSimpleToken.CallOpts, arg0) 905 } 906 907 // DecodeTrieValue is a free data retrieval call binding the contract method 0xb9e59d09. 908 // 909 // Solidity: function decodeTrieValue(bytes trieValue) constant returns(uint256 v) 910 func (_RequestableSimpleToken *RequestableSimpleTokenCaller) DecodeTrieValue(opts *bind.CallOpts, trieValue []byte) (*big.Int, error) { 911 var ( 912 ret0 = new(*big.Int) 913 ) 914 out := ret0 915 err := _RequestableSimpleToken.contract.Call(opts, out, "decodeTrieValue", trieValue) 916 return *ret0, err 917 } 918 919 // DecodeTrieValue is a free data retrieval call binding the contract method 0xb9e59d09. 920 // 921 // Solidity: function decodeTrieValue(bytes trieValue) constant returns(uint256 v) 922 func (_RequestableSimpleToken *RequestableSimpleTokenSession) DecodeTrieValue(trieValue []byte) (*big.Int, error) { 923 return _RequestableSimpleToken.Contract.DecodeTrieValue(&_RequestableSimpleToken.CallOpts, trieValue) 924 } 925 926 // DecodeTrieValue is a free data retrieval call binding the contract method 0xb9e59d09. 927 // 928 // Solidity: function decodeTrieValue(bytes trieValue) constant returns(uint256 v) 929 func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) DecodeTrieValue(trieValue []byte) (*big.Int, error) { 930 return _RequestableSimpleToken.Contract.DecodeTrieValue(&_RequestableSimpleToken.CallOpts, trieValue) 931 } 932 933 // GetBalanceTrieKey is a free data retrieval call binding the contract method 0xb18fcfdf. 934 // 935 // Solidity: function getBalanceTrieKey(address who) constant returns(bytes32) 936 func (_RequestableSimpleToken *RequestableSimpleTokenCaller) GetBalanceTrieKey(opts *bind.CallOpts, who common.Address) ([32]byte, error) { 937 var ( 938 ret0 = new([32]byte) 939 ) 940 out := ret0 941 err := _RequestableSimpleToken.contract.Call(opts, out, "getBalanceTrieKey", who) 942 return *ret0, err 943 } 944 945 // GetBalanceTrieKey is a free data retrieval call binding the contract method 0xb18fcfdf. 946 // 947 // Solidity: function getBalanceTrieKey(address who) constant returns(bytes32) 948 func (_RequestableSimpleToken *RequestableSimpleTokenSession) GetBalanceTrieKey(who common.Address) ([32]byte, error) { 949 return _RequestableSimpleToken.Contract.GetBalanceTrieKey(&_RequestableSimpleToken.CallOpts, who) 950 } 951 952 // GetBalanceTrieKey is a free data retrieval call binding the contract method 0xb18fcfdf. 953 // 954 // Solidity: function getBalanceTrieKey(address who) constant returns(bytes32) 955 func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) GetBalanceTrieKey(who common.Address) ([32]byte, error) { 956 return _RequestableSimpleToken.Contract.GetBalanceTrieKey(&_RequestableSimpleToken.CallOpts, who) 957 } 958 959 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 960 // 961 // Solidity: function isOwner() constant returns(bool) 962 func (_RequestableSimpleToken *RequestableSimpleTokenCaller) IsOwner(opts *bind.CallOpts) (bool, error) { 963 var ( 964 ret0 = new(bool) 965 ) 966 out := ret0 967 err := _RequestableSimpleToken.contract.Call(opts, out, "isOwner") 968 return *ret0, err 969 } 970 971 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 972 // 973 // Solidity: function isOwner() constant returns(bool) 974 func (_RequestableSimpleToken *RequestableSimpleTokenSession) IsOwner() (bool, error) { 975 return _RequestableSimpleToken.Contract.IsOwner(&_RequestableSimpleToken.CallOpts) 976 } 977 978 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 979 // 980 // Solidity: function isOwner() constant returns(bool) 981 func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) IsOwner() (bool, error) { 982 return _RequestableSimpleToken.Contract.IsOwner(&_RequestableSimpleToken.CallOpts) 983 } 984 985 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 986 // 987 // Solidity: function owner() constant returns(address) 988 func (_RequestableSimpleToken *RequestableSimpleTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 989 var ( 990 ret0 = new(common.Address) 991 ) 992 out := ret0 993 err := _RequestableSimpleToken.contract.Call(opts, out, "owner") 994 return *ret0, err 995 } 996 997 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 998 // 999 // Solidity: function owner() constant returns(address) 1000 func (_RequestableSimpleToken *RequestableSimpleTokenSession) Owner() (common.Address, error) { 1001 return _RequestableSimpleToken.Contract.Owner(&_RequestableSimpleToken.CallOpts) 1002 } 1003 1004 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 1005 // 1006 // Solidity: function owner() constant returns(address) 1007 func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) Owner() (common.Address, error) { 1008 return _RequestableSimpleToken.Contract.Owner(&_RequestableSimpleToken.CallOpts) 1009 } 1010 1011 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1012 // 1013 // Solidity: function totalSupply() constant returns(uint256) 1014 func (_RequestableSimpleToken *RequestableSimpleTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 1015 var ( 1016 ret0 = new(*big.Int) 1017 ) 1018 out := ret0 1019 err := _RequestableSimpleToken.contract.Call(opts, out, "totalSupply") 1020 return *ret0, err 1021 } 1022 1023 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1024 // 1025 // Solidity: function totalSupply() constant returns(uint256) 1026 func (_RequestableSimpleToken *RequestableSimpleTokenSession) TotalSupply() (*big.Int, error) { 1027 return _RequestableSimpleToken.Contract.TotalSupply(&_RequestableSimpleToken.CallOpts) 1028 } 1029 1030 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1031 // 1032 // Solidity: function totalSupply() constant returns(uint256) 1033 func (_RequestableSimpleToken *RequestableSimpleTokenCallerSession) TotalSupply() (*big.Int, error) { 1034 return _RequestableSimpleToken.Contract.TotalSupply(&_RequestableSimpleToken.CallOpts) 1035 } 1036 1037 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 1038 // 1039 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 1040 func (_RequestableSimpleToken *RequestableSimpleTokenTransactor) ApplyRequestInChildChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 1041 return _RequestableSimpleToken.contract.Transact(opts, "applyRequestInChildChain", isExit, requestId, requestor, trieKey, trieValue) 1042 } 1043 1044 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 1045 // 1046 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 1047 func (_RequestableSimpleToken *RequestableSimpleTokenSession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 1048 return _RequestableSimpleToken.Contract.ApplyRequestInChildChain(&_RequestableSimpleToken.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 1049 } 1050 1051 // ApplyRequestInChildChain is a paid mutator transaction binding the contract method 0x141ecf46. 1052 // 1053 // Solidity: function applyRequestInChildChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 1054 func (_RequestableSimpleToken *RequestableSimpleTokenTransactorSession) ApplyRequestInChildChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 1055 return _RequestableSimpleToken.Contract.ApplyRequestInChildChain(&_RequestableSimpleToken.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 1056 } 1057 1058 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 1059 // 1060 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 1061 func (_RequestableSimpleToken *RequestableSimpleTokenTransactor) ApplyRequestInRootChain(opts *bind.TransactOpts, isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 1062 return _RequestableSimpleToken.contract.Transact(opts, "applyRequestInRootChain", isExit, requestId, requestor, trieKey, trieValue) 1063 } 1064 1065 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 1066 // 1067 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 1068 func (_RequestableSimpleToken *RequestableSimpleTokenSession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 1069 return _RequestableSimpleToken.Contract.ApplyRequestInRootChain(&_RequestableSimpleToken.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 1070 } 1071 1072 // ApplyRequestInRootChain is a paid mutator transaction binding the contract method 0xa9f79308. 1073 // 1074 // Solidity: function applyRequestInRootChain(bool isExit, uint256 requestId, address requestor, bytes32 trieKey, bytes trieValue) returns(bool success) 1075 func (_RequestableSimpleToken *RequestableSimpleTokenTransactorSession) ApplyRequestInRootChain(isExit bool, requestId *big.Int, requestor common.Address, trieKey [32]byte, trieValue []byte) (*types.Transaction, error) { 1076 return _RequestableSimpleToken.Contract.ApplyRequestInRootChain(&_RequestableSimpleToken.TransactOpts, isExit, requestId, requestor, trieKey, trieValue) 1077 } 1078 1079 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 1080 // 1081 // Solidity: function mint(address _to, uint256 _value) returns() 1082 func (_RequestableSimpleToken *RequestableSimpleTokenTransactor) Mint(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { 1083 return _RequestableSimpleToken.contract.Transact(opts, "mint", _to, _value) 1084 } 1085 1086 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 1087 // 1088 // Solidity: function mint(address _to, uint256 _value) returns() 1089 func (_RequestableSimpleToken *RequestableSimpleTokenSession) Mint(_to common.Address, _value *big.Int) (*types.Transaction, error) { 1090 return _RequestableSimpleToken.Contract.Mint(&_RequestableSimpleToken.TransactOpts, _to, _value) 1091 } 1092 1093 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 1094 // 1095 // Solidity: function mint(address _to, uint256 _value) returns() 1096 func (_RequestableSimpleToken *RequestableSimpleTokenTransactorSession) Mint(_to common.Address, _value *big.Int) (*types.Transaction, error) { 1097 return _RequestableSimpleToken.Contract.Mint(&_RequestableSimpleToken.TransactOpts, _to, _value) 1098 } 1099 1100 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 1101 // 1102 // Solidity: function renounceOwnership() returns() 1103 func (_RequestableSimpleToken *RequestableSimpleTokenTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { 1104 return _RequestableSimpleToken.contract.Transact(opts, "renounceOwnership") 1105 } 1106 1107 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 1108 // 1109 // Solidity: function renounceOwnership() returns() 1110 func (_RequestableSimpleToken *RequestableSimpleTokenSession) RenounceOwnership() (*types.Transaction, error) { 1111 return _RequestableSimpleToken.Contract.RenounceOwnership(&_RequestableSimpleToken.TransactOpts) 1112 } 1113 1114 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 1115 // 1116 // Solidity: function renounceOwnership() returns() 1117 func (_RequestableSimpleToken *RequestableSimpleTokenTransactorSession) RenounceOwnership() (*types.Transaction, error) { 1118 return _RequestableSimpleToken.Contract.RenounceOwnership(&_RequestableSimpleToken.TransactOpts) 1119 } 1120 1121 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1122 // 1123 // Solidity: function transfer(address _to, uint256 _value) returns() 1124 func (_RequestableSimpleToken *RequestableSimpleTokenTransactor) Transfer(opts *bind.TransactOpts, _to common.Address, _value *big.Int) (*types.Transaction, error) { 1125 return _RequestableSimpleToken.contract.Transact(opts, "transfer", _to, _value) 1126 } 1127 1128 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1129 // 1130 // Solidity: function transfer(address _to, uint256 _value) returns() 1131 func (_RequestableSimpleToken *RequestableSimpleTokenSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 1132 return _RequestableSimpleToken.Contract.Transfer(&_RequestableSimpleToken.TransactOpts, _to, _value) 1133 } 1134 1135 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1136 // 1137 // Solidity: function transfer(address _to, uint256 _value) returns() 1138 func (_RequestableSimpleToken *RequestableSimpleTokenTransactorSession) Transfer(_to common.Address, _value *big.Int) (*types.Transaction, error) { 1139 return _RequestableSimpleToken.Contract.Transfer(&_RequestableSimpleToken.TransactOpts, _to, _value) 1140 } 1141 1142 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 1143 // 1144 // Solidity: function transferOwnership(address newOwner) returns() 1145 func (_RequestableSimpleToken *RequestableSimpleTokenTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 1146 return _RequestableSimpleToken.contract.Transact(opts, "transferOwnership", newOwner) 1147 } 1148 1149 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 1150 // 1151 // Solidity: function transferOwnership(address newOwner) returns() 1152 func (_RequestableSimpleToken *RequestableSimpleTokenSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 1153 return _RequestableSimpleToken.Contract.TransferOwnership(&_RequestableSimpleToken.TransactOpts, newOwner) 1154 } 1155 1156 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 1157 // 1158 // Solidity: function transferOwnership(address newOwner) returns() 1159 func (_RequestableSimpleToken *RequestableSimpleTokenTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 1160 return _RequestableSimpleToken.Contract.TransferOwnership(&_RequestableSimpleToken.TransactOpts, newOwner) 1161 } 1162 1163 // RequestableSimpleTokenMintIterator is returned from FilterMint and is used to iterate over the raw logs and unpacked data for Mint events raised by the RequestableSimpleToken contract. 1164 type RequestableSimpleTokenMintIterator struct { 1165 Event *RequestableSimpleTokenMint // Event containing the contract specifics and raw log 1166 1167 contract *bind.BoundContract // Generic contract to use for unpacking event data 1168 event string // Event name to use for unpacking event data 1169 1170 logs chan types.Log // Log channel receiving the found contract events 1171 sub ethereum.Subscription // Subscription for errors, completion and termination 1172 done bool // Whether the subscription completed delivering logs 1173 fail error // Occurred error to stop iteration 1174 } 1175 1176 // Next advances the iterator to the subsequent event, returning whether there 1177 // are any more events found. In case of a retrieval or parsing error, false is 1178 // returned and Error() can be queried for the exact failure. 1179 func (it *RequestableSimpleTokenMintIterator) Next() bool { 1180 // If the iterator failed, stop iterating 1181 if it.fail != nil { 1182 return false 1183 } 1184 // If the iterator completed, deliver directly whatever's available 1185 if it.done { 1186 select { 1187 case log := <-it.logs: 1188 it.Event = new(RequestableSimpleTokenMint) 1189 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1190 it.fail = err 1191 return false 1192 } 1193 it.Event.Raw = log 1194 return true 1195 1196 default: 1197 return false 1198 } 1199 } 1200 // Iterator still in progress, wait for either a data or an error event 1201 select { 1202 case log := <-it.logs: 1203 it.Event = new(RequestableSimpleTokenMint) 1204 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1205 it.fail = err 1206 return false 1207 } 1208 it.Event.Raw = log 1209 return true 1210 1211 case err := <-it.sub.Err(): 1212 it.done = true 1213 it.fail = err 1214 return it.Next() 1215 } 1216 } 1217 1218 // Error returns any retrieval or parsing error occurred during filtering. 1219 func (it *RequestableSimpleTokenMintIterator) Error() error { 1220 return it.fail 1221 } 1222 1223 // Close terminates the iteration process, releasing any pending underlying 1224 // resources. 1225 func (it *RequestableSimpleTokenMintIterator) Close() error { 1226 it.sub.Unsubscribe() 1227 return nil 1228 } 1229 1230 // RequestableSimpleTokenMint represents a Mint event raised by the RequestableSimpleToken contract. 1231 type RequestableSimpleTokenMint struct { 1232 To common.Address 1233 Value *big.Int 1234 Raw types.Log // Blockchain specific contextual infos 1235 } 1236 1237 // FilterMint is a free log retrieval operation binding the contract event 0x0f6798a560793a54c3bcfe86a93cde1e73087d944c0ea20544137d4121396885. 1238 // 1239 // Solidity: event Mint(address _to, uint256 _value) 1240 func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) FilterMint(opts *bind.FilterOpts) (*RequestableSimpleTokenMintIterator, error) { 1241 1242 logs, sub, err := _RequestableSimpleToken.contract.FilterLogs(opts, "Mint") 1243 if err != nil { 1244 return nil, err 1245 } 1246 return &RequestableSimpleTokenMintIterator{contract: _RequestableSimpleToken.contract, event: "Mint", logs: logs, sub: sub}, nil 1247 } 1248 1249 // WatchMint is a free log subscription operation binding the contract event 0x0f6798a560793a54c3bcfe86a93cde1e73087d944c0ea20544137d4121396885. 1250 // 1251 // Solidity: event Mint(address _to, uint256 _value) 1252 func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) WatchMint(opts *bind.WatchOpts, sink chan<- *RequestableSimpleTokenMint) (event.Subscription, error) { 1253 1254 logs, sub, err := _RequestableSimpleToken.contract.WatchLogs(opts, "Mint") 1255 if err != nil { 1256 return nil, err 1257 } 1258 return event.NewSubscription(func(quit <-chan struct{}) error { 1259 defer sub.Unsubscribe() 1260 for { 1261 select { 1262 case log := <-logs: 1263 // New log arrived, parse the event and forward to the user 1264 event := new(RequestableSimpleTokenMint) 1265 if err := _RequestableSimpleToken.contract.UnpackLog(event, "Mint", log); err != nil { 1266 return err 1267 } 1268 event.Raw = log 1269 1270 select { 1271 case sink <- event: 1272 case err := <-sub.Err(): 1273 return err 1274 case <-quit: 1275 return nil 1276 } 1277 case err := <-sub.Err(): 1278 return err 1279 case <-quit: 1280 return nil 1281 } 1282 } 1283 }), nil 1284 } 1285 1286 // ParseMint is a log parse operation binding the contract event 0x0f6798a560793a54c3bcfe86a93cde1e73087d944c0ea20544137d4121396885. 1287 // 1288 // Solidity: event Mint(address _to, uint256 _value) 1289 func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) ParseMint(log types.Log) (*RequestableSimpleTokenMint, error) { 1290 event := new(RequestableSimpleTokenMint) 1291 if err := _RequestableSimpleToken.contract.UnpackLog(event, "Mint", log); err != nil { 1292 return nil, err 1293 } 1294 return event, nil 1295 } 1296 1297 // RequestableSimpleTokenOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the RequestableSimpleToken contract. 1298 type RequestableSimpleTokenOwnershipTransferredIterator struct { 1299 Event *RequestableSimpleTokenOwnershipTransferred // Event containing the contract specifics and raw log 1300 1301 contract *bind.BoundContract // Generic contract to use for unpacking event data 1302 event string // Event name to use for unpacking event data 1303 1304 logs chan types.Log // Log channel receiving the found contract events 1305 sub ethereum.Subscription // Subscription for errors, completion and termination 1306 done bool // Whether the subscription completed delivering logs 1307 fail error // Occurred error to stop iteration 1308 } 1309 1310 // Next advances the iterator to the subsequent event, returning whether there 1311 // are any more events found. In case of a retrieval or parsing error, false is 1312 // returned and Error() can be queried for the exact failure. 1313 func (it *RequestableSimpleTokenOwnershipTransferredIterator) Next() bool { 1314 // If the iterator failed, stop iterating 1315 if it.fail != nil { 1316 return false 1317 } 1318 // If the iterator completed, deliver directly whatever's available 1319 if it.done { 1320 select { 1321 case log := <-it.logs: 1322 it.Event = new(RequestableSimpleTokenOwnershipTransferred) 1323 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1324 it.fail = err 1325 return false 1326 } 1327 it.Event.Raw = log 1328 return true 1329 1330 default: 1331 return false 1332 } 1333 } 1334 // Iterator still in progress, wait for either a data or an error event 1335 select { 1336 case log := <-it.logs: 1337 it.Event = new(RequestableSimpleTokenOwnershipTransferred) 1338 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1339 it.fail = err 1340 return false 1341 } 1342 it.Event.Raw = log 1343 return true 1344 1345 case err := <-it.sub.Err(): 1346 it.done = true 1347 it.fail = err 1348 return it.Next() 1349 } 1350 } 1351 1352 // Error returns any retrieval or parsing error occurred during filtering. 1353 func (it *RequestableSimpleTokenOwnershipTransferredIterator) Error() error { 1354 return it.fail 1355 } 1356 1357 // Close terminates the iteration process, releasing any pending underlying 1358 // resources. 1359 func (it *RequestableSimpleTokenOwnershipTransferredIterator) Close() error { 1360 it.sub.Unsubscribe() 1361 return nil 1362 } 1363 1364 // RequestableSimpleTokenOwnershipTransferred represents a OwnershipTransferred event raised by the RequestableSimpleToken contract. 1365 type RequestableSimpleTokenOwnershipTransferred struct { 1366 PreviousOwner common.Address 1367 NewOwner common.Address 1368 Raw types.Log // Blockchain specific contextual infos 1369 } 1370 1371 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 1372 // 1373 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 1374 func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*RequestableSimpleTokenOwnershipTransferredIterator, error) { 1375 1376 var previousOwnerRule []interface{} 1377 for _, previousOwnerItem := range previousOwner { 1378 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 1379 } 1380 var newOwnerRule []interface{} 1381 for _, newOwnerItem := range newOwner { 1382 newOwnerRule = append(newOwnerRule, newOwnerItem) 1383 } 1384 1385 logs, sub, err := _RequestableSimpleToken.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 1386 if err != nil { 1387 return nil, err 1388 } 1389 return &RequestableSimpleTokenOwnershipTransferredIterator{contract: _RequestableSimpleToken.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 1390 } 1391 1392 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 1393 // 1394 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 1395 func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *RequestableSimpleTokenOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 1396 1397 var previousOwnerRule []interface{} 1398 for _, previousOwnerItem := range previousOwner { 1399 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 1400 } 1401 var newOwnerRule []interface{} 1402 for _, newOwnerItem := range newOwner { 1403 newOwnerRule = append(newOwnerRule, newOwnerItem) 1404 } 1405 1406 logs, sub, err := _RequestableSimpleToken.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 1407 if err != nil { 1408 return nil, err 1409 } 1410 return event.NewSubscription(func(quit <-chan struct{}) error { 1411 defer sub.Unsubscribe() 1412 for { 1413 select { 1414 case log := <-logs: 1415 // New log arrived, parse the event and forward to the user 1416 event := new(RequestableSimpleTokenOwnershipTransferred) 1417 if err := _RequestableSimpleToken.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 1418 return err 1419 } 1420 event.Raw = log 1421 1422 select { 1423 case sink <- event: 1424 case err := <-sub.Err(): 1425 return err 1426 case <-quit: 1427 return nil 1428 } 1429 case err := <-sub.Err(): 1430 return err 1431 case <-quit: 1432 return nil 1433 } 1434 } 1435 }), nil 1436 } 1437 1438 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 1439 // 1440 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 1441 func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) ParseOwnershipTransferred(log types.Log) (*RequestableSimpleTokenOwnershipTransferred, error) { 1442 event := new(RequestableSimpleTokenOwnershipTransferred) 1443 if err := _RequestableSimpleToken.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 1444 return nil, err 1445 } 1446 return event, nil 1447 } 1448 1449 // RequestableSimpleTokenRequestedIterator is returned from FilterRequested and is used to iterate over the raw logs and unpacked data for Requested events raised by the RequestableSimpleToken contract. 1450 type RequestableSimpleTokenRequestedIterator struct { 1451 Event *RequestableSimpleTokenRequested // Event containing the contract specifics and raw log 1452 1453 contract *bind.BoundContract // Generic contract to use for unpacking event data 1454 event string // Event name to use for unpacking event data 1455 1456 logs chan types.Log // Log channel receiving the found contract events 1457 sub ethereum.Subscription // Subscription for errors, completion and termination 1458 done bool // Whether the subscription completed delivering logs 1459 fail error // Occurred error to stop iteration 1460 } 1461 1462 // Next advances the iterator to the subsequent event, returning whether there 1463 // are any more events found. In case of a retrieval or parsing error, false is 1464 // returned and Error() can be queried for the exact failure. 1465 func (it *RequestableSimpleTokenRequestedIterator) Next() bool { 1466 // If the iterator failed, stop iterating 1467 if it.fail != nil { 1468 return false 1469 } 1470 // If the iterator completed, deliver directly whatever's available 1471 if it.done { 1472 select { 1473 case log := <-it.logs: 1474 it.Event = new(RequestableSimpleTokenRequested) 1475 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1476 it.fail = err 1477 return false 1478 } 1479 it.Event.Raw = log 1480 return true 1481 1482 default: 1483 return false 1484 } 1485 } 1486 // Iterator still in progress, wait for either a data or an error event 1487 select { 1488 case log := <-it.logs: 1489 it.Event = new(RequestableSimpleTokenRequested) 1490 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1491 it.fail = err 1492 return false 1493 } 1494 it.Event.Raw = log 1495 return true 1496 1497 case err := <-it.sub.Err(): 1498 it.done = true 1499 it.fail = err 1500 return it.Next() 1501 } 1502 } 1503 1504 // Error returns any retrieval or parsing error occurred during filtering. 1505 func (it *RequestableSimpleTokenRequestedIterator) Error() error { 1506 return it.fail 1507 } 1508 1509 // Close terminates the iteration process, releasing any pending underlying 1510 // resources. 1511 func (it *RequestableSimpleTokenRequestedIterator) Close() error { 1512 it.sub.Unsubscribe() 1513 return nil 1514 } 1515 1516 // RequestableSimpleTokenRequested represents a Requested event raised by the RequestableSimpleToken contract. 1517 type RequestableSimpleTokenRequested struct { 1518 IsExit bool 1519 Requestor common.Address 1520 TrieKey [32]byte 1521 TrieValue []byte 1522 Raw types.Log // Blockchain specific contextual infos 1523 } 1524 1525 // FilterRequested is a free log retrieval operation binding the contract event 0xc9cca1cafbefa6d9c2ec79c95fc6e689905c6e96616a1e7406f13cf725f3cd15. 1526 // 1527 // Solidity: event Requested(bool _isExit, address _requestor, bytes32 _trieKey, bytes _trieValue) 1528 func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) FilterRequested(opts *bind.FilterOpts) (*RequestableSimpleTokenRequestedIterator, error) { 1529 1530 logs, sub, err := _RequestableSimpleToken.contract.FilterLogs(opts, "Requested") 1531 if err != nil { 1532 return nil, err 1533 } 1534 return &RequestableSimpleTokenRequestedIterator{contract: _RequestableSimpleToken.contract, event: "Requested", logs: logs, sub: sub}, nil 1535 } 1536 1537 // WatchRequested is a free log subscription operation binding the contract event 0xc9cca1cafbefa6d9c2ec79c95fc6e689905c6e96616a1e7406f13cf725f3cd15. 1538 // 1539 // Solidity: event Requested(bool _isExit, address _requestor, bytes32 _trieKey, bytes _trieValue) 1540 func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) WatchRequested(opts *bind.WatchOpts, sink chan<- *RequestableSimpleTokenRequested) (event.Subscription, error) { 1541 1542 logs, sub, err := _RequestableSimpleToken.contract.WatchLogs(opts, "Requested") 1543 if err != nil { 1544 return nil, err 1545 } 1546 return event.NewSubscription(func(quit <-chan struct{}) error { 1547 defer sub.Unsubscribe() 1548 for { 1549 select { 1550 case log := <-logs: 1551 // New log arrived, parse the event and forward to the user 1552 event := new(RequestableSimpleTokenRequested) 1553 if err := _RequestableSimpleToken.contract.UnpackLog(event, "Requested", log); err != nil { 1554 return err 1555 } 1556 event.Raw = log 1557 1558 select { 1559 case sink <- event: 1560 case err := <-sub.Err(): 1561 return err 1562 case <-quit: 1563 return nil 1564 } 1565 case err := <-sub.Err(): 1566 return err 1567 case <-quit: 1568 return nil 1569 } 1570 } 1571 }), nil 1572 } 1573 1574 // ParseRequested is a log parse operation binding the contract event 0xc9cca1cafbefa6d9c2ec79c95fc6e689905c6e96616a1e7406f13cf725f3cd15. 1575 // 1576 // Solidity: event Requested(bool _isExit, address _requestor, bytes32 _trieKey, bytes _trieValue) 1577 func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) ParseRequested(log types.Log) (*RequestableSimpleTokenRequested, error) { 1578 event := new(RequestableSimpleTokenRequested) 1579 if err := _RequestableSimpleToken.contract.UnpackLog(event, "Requested", log); err != nil { 1580 return nil, err 1581 } 1582 return event, nil 1583 } 1584 1585 // RequestableSimpleTokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the RequestableSimpleToken contract. 1586 type RequestableSimpleTokenTransferIterator struct { 1587 Event *RequestableSimpleTokenTransfer // Event containing the contract specifics and raw log 1588 1589 contract *bind.BoundContract // Generic contract to use for unpacking event data 1590 event string // Event name to use for unpacking event data 1591 1592 logs chan types.Log // Log channel receiving the found contract events 1593 sub ethereum.Subscription // Subscription for errors, completion and termination 1594 done bool // Whether the subscription completed delivering logs 1595 fail error // Occurred error to stop iteration 1596 } 1597 1598 // Next advances the iterator to the subsequent event, returning whether there 1599 // are any more events found. In case of a retrieval or parsing error, false is 1600 // returned and Error() can be queried for the exact failure. 1601 func (it *RequestableSimpleTokenTransferIterator) Next() bool { 1602 // If the iterator failed, stop iterating 1603 if it.fail != nil { 1604 return false 1605 } 1606 // If the iterator completed, deliver directly whatever's available 1607 if it.done { 1608 select { 1609 case log := <-it.logs: 1610 it.Event = new(RequestableSimpleTokenTransfer) 1611 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1612 it.fail = err 1613 return false 1614 } 1615 it.Event.Raw = log 1616 return true 1617 1618 default: 1619 return false 1620 } 1621 } 1622 // Iterator still in progress, wait for either a data or an error event 1623 select { 1624 case log := <-it.logs: 1625 it.Event = new(RequestableSimpleTokenTransfer) 1626 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1627 it.fail = err 1628 return false 1629 } 1630 it.Event.Raw = log 1631 return true 1632 1633 case err := <-it.sub.Err(): 1634 it.done = true 1635 it.fail = err 1636 return it.Next() 1637 } 1638 } 1639 1640 // Error returns any retrieval or parsing error occurred during filtering. 1641 func (it *RequestableSimpleTokenTransferIterator) Error() error { 1642 return it.fail 1643 } 1644 1645 // Close terminates the iteration process, releasing any pending underlying 1646 // resources. 1647 func (it *RequestableSimpleTokenTransferIterator) Close() error { 1648 it.sub.Unsubscribe() 1649 return nil 1650 } 1651 1652 // RequestableSimpleTokenTransfer represents a Transfer event raised by the RequestableSimpleToken contract. 1653 type RequestableSimpleTokenTransfer struct { 1654 From common.Address 1655 To common.Address 1656 Value *big.Int 1657 Raw types.Log // Blockchain specific contextual infos 1658 } 1659 1660 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 1661 // 1662 // Solidity: event Transfer(address _from, address _to, uint256 _value) 1663 func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) FilterTransfer(opts *bind.FilterOpts) (*RequestableSimpleTokenTransferIterator, error) { 1664 1665 logs, sub, err := _RequestableSimpleToken.contract.FilterLogs(opts, "Transfer") 1666 if err != nil { 1667 return nil, err 1668 } 1669 return &RequestableSimpleTokenTransferIterator{contract: _RequestableSimpleToken.contract, event: "Transfer", logs: logs, sub: sub}, nil 1670 } 1671 1672 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 1673 // 1674 // Solidity: event Transfer(address _from, address _to, uint256 _value) 1675 func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *RequestableSimpleTokenTransfer) (event.Subscription, error) { 1676 1677 logs, sub, err := _RequestableSimpleToken.contract.WatchLogs(opts, "Transfer") 1678 if err != nil { 1679 return nil, err 1680 } 1681 return event.NewSubscription(func(quit <-chan struct{}) error { 1682 defer sub.Unsubscribe() 1683 for { 1684 select { 1685 case log := <-logs: 1686 // New log arrived, parse the event and forward to the user 1687 event := new(RequestableSimpleTokenTransfer) 1688 if err := _RequestableSimpleToken.contract.UnpackLog(event, "Transfer", log); err != nil { 1689 return err 1690 } 1691 event.Raw = log 1692 1693 select { 1694 case sink <- event: 1695 case err := <-sub.Err(): 1696 return err 1697 case <-quit: 1698 return nil 1699 } 1700 case err := <-sub.Err(): 1701 return err 1702 case <-quit: 1703 return nil 1704 } 1705 } 1706 }), nil 1707 } 1708 1709 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 1710 // 1711 // Solidity: event Transfer(address _from, address _to, uint256 _value) 1712 func (_RequestableSimpleToken *RequestableSimpleTokenFilterer) ParseTransfer(log types.Log) (*RequestableSimpleTokenTransfer, error) { 1713 event := new(RequestableSimpleTokenTransfer) 1714 if err := _RequestableSimpleToken.contract.UnpackLog(event, "Transfer", log); err != nil { 1715 return nil, err 1716 } 1717 return event, nil 1718 } 1719 1720 // SafeMathABI is the input ABI used to generate the binding from. 1721 const SafeMathABI = "[]" 1722 1723 // SafeMathBin is the compiled bytecode used for deploying new contracts. 1724 var SafeMathBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582081abea5b57eb862cc535e559557e86893bc93410acfd1b3122d48a2c0cdee52a64736f6c634300050c0032" 1725 1726 // DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it. 1727 func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error) { 1728 parsed, err := abi.JSON(strings.NewReader(SafeMathABI)) 1729 if err != nil { 1730 return common.Address{}, nil, nil, err 1731 } 1732 1733 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SafeMathBin), backend) 1734 if err != nil { 1735 return common.Address{}, nil, nil, err 1736 } 1737 return address, tx, &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil 1738 } 1739 1740 // SafeMath is an auto generated Go binding around an Ethereum contract. 1741 type SafeMath struct { 1742 SafeMathCaller // Read-only binding to the contract 1743 SafeMathTransactor // Write-only binding to the contract 1744 SafeMathFilterer // Log filterer for contract events 1745 } 1746 1747 // SafeMathCaller is an auto generated read-only Go binding around an Ethereum contract. 1748 type SafeMathCaller struct { 1749 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1750 } 1751 1752 // SafeMathTransactor is an auto generated write-only Go binding around an Ethereum contract. 1753 type SafeMathTransactor struct { 1754 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1755 } 1756 1757 // SafeMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 1758 type SafeMathFilterer struct { 1759 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1760 } 1761 1762 // SafeMathSession is an auto generated Go binding around an Ethereum contract, 1763 // with pre-set call and transact options. 1764 type SafeMathSession struct { 1765 Contract *SafeMath // Generic contract binding to set the session for 1766 CallOpts bind.CallOpts // Call options to use throughout this session 1767 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1768 } 1769 1770 // SafeMathCallerSession is an auto generated read-only Go binding around an Ethereum contract, 1771 // with pre-set call options. 1772 type SafeMathCallerSession struct { 1773 Contract *SafeMathCaller // Generic contract caller binding to set the session for 1774 CallOpts bind.CallOpts // Call options to use throughout this session 1775 } 1776 1777 // SafeMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 1778 // with pre-set transact options. 1779 type SafeMathTransactorSession struct { 1780 Contract *SafeMathTransactor // Generic contract transactor binding to set the session for 1781 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1782 } 1783 1784 // SafeMathRaw is an auto generated low-level Go binding around an Ethereum contract. 1785 type SafeMathRaw struct { 1786 Contract *SafeMath // Generic contract binding to access the raw methods on 1787 } 1788 1789 // SafeMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 1790 type SafeMathCallerRaw struct { 1791 Contract *SafeMathCaller // Generic read-only contract binding to access the raw methods on 1792 } 1793 1794 // SafeMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 1795 type SafeMathTransactorRaw struct { 1796 Contract *SafeMathTransactor // Generic write-only contract binding to access the raw methods on 1797 } 1798 1799 // NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract. 1800 func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error) { 1801 contract, err := bindSafeMath(address, backend, backend, backend) 1802 if err != nil { 1803 return nil, err 1804 } 1805 return &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil 1806 } 1807 1808 // NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract. 1809 func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error) { 1810 contract, err := bindSafeMath(address, caller, nil, nil) 1811 if err != nil { 1812 return nil, err 1813 } 1814 return &SafeMathCaller{contract: contract}, nil 1815 } 1816 1817 // NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract. 1818 func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error) { 1819 contract, err := bindSafeMath(address, nil, transactor, nil) 1820 if err != nil { 1821 return nil, err 1822 } 1823 return &SafeMathTransactor{contract: contract}, nil 1824 } 1825 1826 // NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract. 1827 func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error) { 1828 contract, err := bindSafeMath(address, nil, nil, filterer) 1829 if err != nil { 1830 return nil, err 1831 } 1832 return &SafeMathFilterer{contract: contract}, nil 1833 } 1834 1835 // bindSafeMath binds a generic wrapper to an already deployed contract. 1836 func bindSafeMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 1837 parsed, err := abi.JSON(strings.NewReader(SafeMathABI)) 1838 if err != nil { 1839 return nil, err 1840 } 1841 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 1842 } 1843 1844 // Call invokes the (constant) contract method with params as input values and 1845 // sets the output to result. The result type might be a single field for simple 1846 // returns, a slice of interfaces for anonymous returns and a struct for named 1847 // returns. 1848 func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 1849 return _SafeMath.Contract.SafeMathCaller.contract.Call(opts, result, method, params...) 1850 } 1851 1852 // Transfer initiates a plain transaction to move funds to the contract, calling 1853 // its default method if one is available. 1854 func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1855 return _SafeMath.Contract.SafeMathTransactor.contract.Transfer(opts) 1856 } 1857 1858 // Transact invokes the (paid) contract method with params as input values. 1859 func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1860 return _SafeMath.Contract.SafeMathTransactor.contract.Transact(opts, method, params...) 1861 } 1862 1863 // Call invokes the (constant) contract method with params as input values and 1864 // sets the output to result. The result type might be a single field for simple 1865 // returns, a slice of interfaces for anonymous returns and a struct for named 1866 // returns. 1867 func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 1868 return _SafeMath.Contract.contract.Call(opts, result, method, params...) 1869 } 1870 1871 // Transfer initiates a plain transaction to move funds to the contract, calling 1872 // its default method if one is available. 1873 func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1874 return _SafeMath.Contract.contract.Transfer(opts) 1875 } 1876 1877 // Transact invokes the (paid) contract method with params as input values. 1878 func (_SafeMath *SafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1879 return _SafeMath.Contract.contract.Transact(opts, method, params...) 1880 }