github.com/Onther-Tech/plasma-evm@v0.0.0-rc7.7/contracts/plasma/depositmanager/depositmanager.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 depositmanager 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 // AddressABI is the input ABI used to generate the binding from. 31 const AddressABI = "[]" 32 33 // AddressBin is the compiled bytecode used for deploying new contracts. 34 var AddressBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a72315820caa83848f6f3a88a061ce398577e989d5da9a19232f9e00175de410a704b86e164736f6c634300050c0032" 35 36 // DeployAddress deploys a new Ethereum contract, binding an instance of Address to it. 37 func DeployAddress(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Address, error) { 38 parsed, err := abi.JSON(strings.NewReader(AddressABI)) 39 if err != nil { 40 return common.Address{}, nil, nil, err 41 } 42 43 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(AddressBin), backend) 44 if err != nil { 45 return common.Address{}, nil, nil, err 46 } 47 return address, tx, &Address{AddressCaller: AddressCaller{contract: contract}, AddressTransactor: AddressTransactor{contract: contract}, AddressFilterer: AddressFilterer{contract: contract}}, nil 48 } 49 50 // Address is an auto generated Go binding around an Ethereum contract. 51 type Address struct { 52 AddressCaller // Read-only binding to the contract 53 AddressTransactor // Write-only binding to the contract 54 AddressFilterer // Log filterer for contract events 55 } 56 57 // AddressCaller is an auto generated read-only Go binding around an Ethereum contract. 58 type AddressCaller struct { 59 contract *bind.BoundContract // Generic contract wrapper for the low level calls 60 } 61 62 // AddressTransactor is an auto generated write-only Go binding around an Ethereum contract. 63 type AddressTransactor struct { 64 contract *bind.BoundContract // Generic contract wrapper for the low level calls 65 } 66 67 // AddressFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 68 type AddressFilterer struct { 69 contract *bind.BoundContract // Generic contract wrapper for the low level calls 70 } 71 72 // AddressSession is an auto generated Go binding around an Ethereum contract, 73 // with pre-set call and transact options. 74 type AddressSession struct { 75 Contract *Address // Generic contract binding to set the session for 76 CallOpts bind.CallOpts // Call options to use throughout this session 77 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 78 } 79 80 // AddressCallerSession is an auto generated read-only Go binding around an Ethereum contract, 81 // with pre-set call options. 82 type AddressCallerSession struct { 83 Contract *AddressCaller // Generic contract caller binding to set the session for 84 CallOpts bind.CallOpts // Call options to use throughout this session 85 } 86 87 // AddressTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 88 // with pre-set transact options. 89 type AddressTransactorSession struct { 90 Contract *AddressTransactor // Generic contract transactor binding to set the session for 91 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 92 } 93 94 // AddressRaw is an auto generated low-level Go binding around an Ethereum contract. 95 type AddressRaw struct { 96 Contract *Address // Generic contract binding to access the raw methods on 97 } 98 99 // AddressCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 100 type AddressCallerRaw struct { 101 Contract *AddressCaller // Generic read-only contract binding to access the raw methods on 102 } 103 104 // AddressTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 105 type AddressTransactorRaw struct { 106 Contract *AddressTransactor // Generic write-only contract binding to access the raw methods on 107 } 108 109 // NewAddress creates a new instance of Address, bound to a specific deployed contract. 110 func NewAddress(address common.Address, backend bind.ContractBackend) (*Address, error) { 111 contract, err := bindAddress(address, backend, backend, backend) 112 if err != nil { 113 return nil, err 114 } 115 return &Address{AddressCaller: AddressCaller{contract: contract}, AddressTransactor: AddressTransactor{contract: contract}, AddressFilterer: AddressFilterer{contract: contract}}, nil 116 } 117 118 // NewAddressCaller creates a new read-only instance of Address, bound to a specific deployed contract. 119 func NewAddressCaller(address common.Address, caller bind.ContractCaller) (*AddressCaller, error) { 120 contract, err := bindAddress(address, caller, nil, nil) 121 if err != nil { 122 return nil, err 123 } 124 return &AddressCaller{contract: contract}, nil 125 } 126 127 // NewAddressTransactor creates a new write-only instance of Address, bound to a specific deployed contract. 128 func NewAddressTransactor(address common.Address, transactor bind.ContractTransactor) (*AddressTransactor, error) { 129 contract, err := bindAddress(address, nil, transactor, nil) 130 if err != nil { 131 return nil, err 132 } 133 return &AddressTransactor{contract: contract}, nil 134 } 135 136 // NewAddressFilterer creates a new log filterer instance of Address, bound to a specific deployed contract. 137 func NewAddressFilterer(address common.Address, filterer bind.ContractFilterer) (*AddressFilterer, error) { 138 contract, err := bindAddress(address, nil, nil, filterer) 139 if err != nil { 140 return nil, err 141 } 142 return &AddressFilterer{contract: contract}, nil 143 } 144 145 // bindAddress binds a generic wrapper to an already deployed contract. 146 func bindAddress(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 147 parsed, err := abi.JSON(strings.NewReader(AddressABI)) 148 if err != nil { 149 return nil, err 150 } 151 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 152 } 153 154 // Call invokes the (constant) contract method with params as input values and 155 // sets the output to result. The result type might be a single field for simple 156 // returns, a slice of interfaces for anonymous returns and a struct for named 157 // returns. 158 func (_Address *AddressRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 159 return _Address.Contract.AddressCaller.contract.Call(opts, result, method, params...) 160 } 161 162 // Transfer initiates a plain transaction to move funds to the contract, calling 163 // its default method if one is available. 164 func (_Address *AddressRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 165 return _Address.Contract.AddressTransactor.contract.Transfer(opts) 166 } 167 168 // Transact invokes the (paid) contract method with params as input values. 169 func (_Address *AddressRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 170 return _Address.Contract.AddressTransactor.contract.Transact(opts, method, params...) 171 } 172 173 // Call invokes the (constant) contract method with params as input values and 174 // sets the output to result. The result type might be a single field for simple 175 // returns, a slice of interfaces for anonymous returns and a struct for named 176 // returns. 177 func (_Address *AddressCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 178 return _Address.Contract.contract.Call(opts, result, method, params...) 179 } 180 181 // Transfer initiates a plain transaction to move funds to the contract, calling 182 // its default method if one is available. 183 func (_Address *AddressTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 184 return _Address.Contract.contract.Transfer(opts) 185 } 186 187 // Transact invokes the (paid) contract method with params as input values. 188 func (_Address *AddressTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 189 return _Address.Contract.contract.Transact(opts, method, params...) 190 } 191 192 // AuthControllerABI is the input ABI used to generate the binding from. 193 const AuthControllerABI = "[{\"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\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"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\"}]" 194 195 // AuthControllerFuncSigs maps the 4-byte function signature to its string representation. 196 var AuthControllerFuncSigs = map[string]string{ 197 "8f32d59b": "isOwner()", 198 "8da5cb5b": "owner()", 199 "5f112c68": "renounceMinter(address)", 200 "715018a6": "renounceOwnership()", 201 "38bf3cfa": "renounceOwnership(address)", 202 "41eb24bb": "renouncePauser(address)", 203 "f2fde38b": "transferOwnership(address)", 204 "6d435421": "transferOwnership(address,address)", 205 } 206 207 // AuthControllerBin is the compiled bytecode used for deploying new contracts. 208 var AuthControllerBin = "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" 209 210 // DeployAuthController deploys a new Ethereum contract, binding an instance of AuthController to it. 211 func DeployAuthController(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *AuthController, error) { 212 parsed, err := abi.JSON(strings.NewReader(AuthControllerABI)) 213 if err != nil { 214 return common.Address{}, nil, nil, err 215 } 216 217 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(AuthControllerBin), backend) 218 if err != nil { 219 return common.Address{}, nil, nil, err 220 } 221 return address, tx, &AuthController{AuthControllerCaller: AuthControllerCaller{contract: contract}, AuthControllerTransactor: AuthControllerTransactor{contract: contract}, AuthControllerFilterer: AuthControllerFilterer{contract: contract}}, nil 222 } 223 224 // AuthController is an auto generated Go binding around an Ethereum contract. 225 type AuthController struct { 226 AuthControllerCaller // Read-only binding to the contract 227 AuthControllerTransactor // Write-only binding to the contract 228 AuthControllerFilterer // Log filterer for contract events 229 } 230 231 // AuthControllerCaller is an auto generated read-only Go binding around an Ethereum contract. 232 type AuthControllerCaller struct { 233 contract *bind.BoundContract // Generic contract wrapper for the low level calls 234 } 235 236 // AuthControllerTransactor is an auto generated write-only Go binding around an Ethereum contract. 237 type AuthControllerTransactor struct { 238 contract *bind.BoundContract // Generic contract wrapper for the low level calls 239 } 240 241 // AuthControllerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 242 type AuthControllerFilterer struct { 243 contract *bind.BoundContract // Generic contract wrapper for the low level calls 244 } 245 246 // AuthControllerSession is an auto generated Go binding around an Ethereum contract, 247 // with pre-set call and transact options. 248 type AuthControllerSession struct { 249 Contract *AuthController // Generic contract binding to set the session for 250 CallOpts bind.CallOpts // Call options to use throughout this session 251 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 252 } 253 254 // AuthControllerCallerSession is an auto generated read-only Go binding around an Ethereum contract, 255 // with pre-set call options. 256 type AuthControllerCallerSession struct { 257 Contract *AuthControllerCaller // Generic contract caller binding to set the session for 258 CallOpts bind.CallOpts // Call options to use throughout this session 259 } 260 261 // AuthControllerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 262 // with pre-set transact options. 263 type AuthControllerTransactorSession struct { 264 Contract *AuthControllerTransactor // Generic contract transactor binding to set the session for 265 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 266 } 267 268 // AuthControllerRaw is an auto generated low-level Go binding around an Ethereum contract. 269 type AuthControllerRaw struct { 270 Contract *AuthController // Generic contract binding to access the raw methods on 271 } 272 273 // AuthControllerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 274 type AuthControllerCallerRaw struct { 275 Contract *AuthControllerCaller // Generic read-only contract binding to access the raw methods on 276 } 277 278 // AuthControllerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 279 type AuthControllerTransactorRaw struct { 280 Contract *AuthControllerTransactor // Generic write-only contract binding to access the raw methods on 281 } 282 283 // NewAuthController creates a new instance of AuthController, bound to a specific deployed contract. 284 func NewAuthController(address common.Address, backend bind.ContractBackend) (*AuthController, error) { 285 contract, err := bindAuthController(address, backend, backend, backend) 286 if err != nil { 287 return nil, err 288 } 289 return &AuthController{AuthControllerCaller: AuthControllerCaller{contract: contract}, AuthControllerTransactor: AuthControllerTransactor{contract: contract}, AuthControllerFilterer: AuthControllerFilterer{contract: contract}}, nil 290 } 291 292 // NewAuthControllerCaller creates a new read-only instance of AuthController, bound to a specific deployed contract. 293 func NewAuthControllerCaller(address common.Address, caller bind.ContractCaller) (*AuthControllerCaller, error) { 294 contract, err := bindAuthController(address, caller, nil, nil) 295 if err != nil { 296 return nil, err 297 } 298 return &AuthControllerCaller{contract: contract}, nil 299 } 300 301 // NewAuthControllerTransactor creates a new write-only instance of AuthController, bound to a specific deployed contract. 302 func NewAuthControllerTransactor(address common.Address, transactor bind.ContractTransactor) (*AuthControllerTransactor, error) { 303 contract, err := bindAuthController(address, nil, transactor, nil) 304 if err != nil { 305 return nil, err 306 } 307 return &AuthControllerTransactor{contract: contract}, nil 308 } 309 310 // NewAuthControllerFilterer creates a new log filterer instance of AuthController, bound to a specific deployed contract. 311 func NewAuthControllerFilterer(address common.Address, filterer bind.ContractFilterer) (*AuthControllerFilterer, error) { 312 contract, err := bindAuthController(address, nil, nil, filterer) 313 if err != nil { 314 return nil, err 315 } 316 return &AuthControllerFilterer{contract: contract}, nil 317 } 318 319 // bindAuthController binds a generic wrapper to an already deployed contract. 320 func bindAuthController(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 321 parsed, err := abi.JSON(strings.NewReader(AuthControllerABI)) 322 if err != nil { 323 return nil, err 324 } 325 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 326 } 327 328 // Call invokes the (constant) contract method with params as input values and 329 // sets the output to result. The result type might be a single field for simple 330 // returns, a slice of interfaces for anonymous returns and a struct for named 331 // returns. 332 func (_AuthController *AuthControllerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 333 return _AuthController.Contract.AuthControllerCaller.contract.Call(opts, result, method, params...) 334 } 335 336 // Transfer initiates a plain transaction to move funds to the contract, calling 337 // its default method if one is available. 338 func (_AuthController *AuthControllerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 339 return _AuthController.Contract.AuthControllerTransactor.contract.Transfer(opts) 340 } 341 342 // Transact invokes the (paid) contract method with params as input values. 343 func (_AuthController *AuthControllerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 344 return _AuthController.Contract.AuthControllerTransactor.contract.Transact(opts, method, params...) 345 } 346 347 // Call invokes the (constant) contract method with params as input values and 348 // sets the output to result. The result type might be a single field for simple 349 // returns, a slice of interfaces for anonymous returns and a struct for named 350 // returns. 351 func (_AuthController *AuthControllerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 352 return _AuthController.Contract.contract.Call(opts, result, method, params...) 353 } 354 355 // Transfer initiates a plain transaction to move funds to the contract, calling 356 // its default method if one is available. 357 func (_AuthController *AuthControllerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 358 return _AuthController.Contract.contract.Transfer(opts) 359 } 360 361 // Transact invokes the (paid) contract method with params as input values. 362 func (_AuthController *AuthControllerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 363 return _AuthController.Contract.contract.Transact(opts, method, params...) 364 } 365 366 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 367 // 368 // Solidity: function isOwner() constant returns(bool) 369 func (_AuthController *AuthControllerCaller) IsOwner(opts *bind.CallOpts) (bool, error) { 370 var ( 371 ret0 = new(bool) 372 ) 373 out := ret0 374 err := _AuthController.contract.Call(opts, out, "isOwner") 375 return *ret0, err 376 } 377 378 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 379 // 380 // Solidity: function isOwner() constant returns(bool) 381 func (_AuthController *AuthControllerSession) IsOwner() (bool, error) { 382 return _AuthController.Contract.IsOwner(&_AuthController.CallOpts) 383 } 384 385 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 386 // 387 // Solidity: function isOwner() constant returns(bool) 388 func (_AuthController *AuthControllerCallerSession) IsOwner() (bool, error) { 389 return _AuthController.Contract.IsOwner(&_AuthController.CallOpts) 390 } 391 392 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 393 // 394 // Solidity: function owner() constant returns(address) 395 func (_AuthController *AuthControllerCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 396 var ( 397 ret0 = new(common.Address) 398 ) 399 out := ret0 400 err := _AuthController.contract.Call(opts, out, "owner") 401 return *ret0, err 402 } 403 404 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 405 // 406 // Solidity: function owner() constant returns(address) 407 func (_AuthController *AuthControllerSession) Owner() (common.Address, error) { 408 return _AuthController.Contract.Owner(&_AuthController.CallOpts) 409 } 410 411 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 412 // 413 // Solidity: function owner() constant returns(address) 414 func (_AuthController *AuthControllerCallerSession) Owner() (common.Address, error) { 415 return _AuthController.Contract.Owner(&_AuthController.CallOpts) 416 } 417 418 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 419 // 420 // Solidity: function renounceMinter(address target) returns() 421 func (_AuthController *AuthControllerTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 422 return _AuthController.contract.Transact(opts, "renounceMinter", target) 423 } 424 425 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 426 // 427 // Solidity: function renounceMinter(address target) returns() 428 func (_AuthController *AuthControllerSession) RenounceMinter(target common.Address) (*types.Transaction, error) { 429 return _AuthController.Contract.RenounceMinter(&_AuthController.TransactOpts, target) 430 } 431 432 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 433 // 434 // Solidity: function renounceMinter(address target) returns() 435 func (_AuthController *AuthControllerTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) { 436 return _AuthController.Contract.RenounceMinter(&_AuthController.TransactOpts, target) 437 } 438 439 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 440 // 441 // Solidity: function renounceOwnership(address target) returns() 442 func (_AuthController *AuthControllerTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 443 return _AuthController.contract.Transact(opts, "renounceOwnership", target) 444 } 445 446 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 447 // 448 // Solidity: function renounceOwnership(address target) returns() 449 func (_AuthController *AuthControllerSession) RenounceOwnership(target common.Address) (*types.Transaction, error) { 450 return _AuthController.Contract.RenounceOwnership(&_AuthController.TransactOpts, target) 451 } 452 453 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 454 // 455 // Solidity: function renounceOwnership(address target) returns() 456 func (_AuthController *AuthControllerTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) { 457 return _AuthController.Contract.RenounceOwnership(&_AuthController.TransactOpts, target) 458 } 459 460 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 461 // 462 // Solidity: function renounceOwnership() returns() 463 func (_AuthController *AuthControllerTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) { 464 return _AuthController.contract.Transact(opts, "renounceOwnership0") 465 } 466 467 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 468 // 469 // Solidity: function renounceOwnership() returns() 470 func (_AuthController *AuthControllerSession) RenounceOwnership0() (*types.Transaction, error) { 471 return _AuthController.Contract.RenounceOwnership0(&_AuthController.TransactOpts) 472 } 473 474 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 475 // 476 // Solidity: function renounceOwnership() returns() 477 func (_AuthController *AuthControllerTransactorSession) RenounceOwnership0() (*types.Transaction, error) { 478 return _AuthController.Contract.RenounceOwnership0(&_AuthController.TransactOpts) 479 } 480 481 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 482 // 483 // Solidity: function renouncePauser(address target) returns() 484 func (_AuthController *AuthControllerTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 485 return _AuthController.contract.Transact(opts, "renouncePauser", target) 486 } 487 488 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 489 // 490 // Solidity: function renouncePauser(address target) returns() 491 func (_AuthController *AuthControllerSession) RenouncePauser(target common.Address) (*types.Transaction, error) { 492 return _AuthController.Contract.RenouncePauser(&_AuthController.TransactOpts, target) 493 } 494 495 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 496 // 497 // Solidity: function renouncePauser(address target) returns() 498 func (_AuthController *AuthControllerTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) { 499 return _AuthController.Contract.RenouncePauser(&_AuthController.TransactOpts, target) 500 } 501 502 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 503 // 504 // Solidity: function transferOwnership(address target, address newOwner) returns() 505 func (_AuthController *AuthControllerTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) { 506 return _AuthController.contract.Transact(opts, "transferOwnership", target, newOwner) 507 } 508 509 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 510 // 511 // Solidity: function transferOwnership(address target, address newOwner) returns() 512 func (_AuthController *AuthControllerSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) { 513 return _AuthController.Contract.TransferOwnership(&_AuthController.TransactOpts, target, newOwner) 514 } 515 516 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 517 // 518 // Solidity: function transferOwnership(address target, address newOwner) returns() 519 func (_AuthController *AuthControllerTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) { 520 return _AuthController.Contract.TransferOwnership(&_AuthController.TransactOpts, target, newOwner) 521 } 522 523 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 524 // 525 // Solidity: function transferOwnership(address newOwner) returns() 526 func (_AuthController *AuthControllerTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 527 return _AuthController.contract.Transact(opts, "transferOwnership0", newOwner) 528 } 529 530 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 531 // 532 // Solidity: function transferOwnership(address newOwner) returns() 533 func (_AuthController *AuthControllerSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) { 534 return _AuthController.Contract.TransferOwnership0(&_AuthController.TransactOpts, newOwner) 535 } 536 537 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 538 // 539 // Solidity: function transferOwnership(address newOwner) returns() 540 func (_AuthController *AuthControllerTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) { 541 return _AuthController.Contract.TransferOwnership0(&_AuthController.TransactOpts, newOwner) 542 } 543 544 // AuthControllerOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the AuthController contract. 545 type AuthControllerOwnershipTransferredIterator struct { 546 Event *AuthControllerOwnershipTransferred // Event containing the contract specifics and raw log 547 548 contract *bind.BoundContract // Generic contract to use for unpacking event data 549 event string // Event name to use for unpacking event data 550 551 logs chan types.Log // Log channel receiving the found contract events 552 sub ethereum.Subscription // Subscription for errors, completion and termination 553 done bool // Whether the subscription completed delivering logs 554 fail error // Occurred error to stop iteration 555 } 556 557 // Next advances the iterator to the subsequent event, returning whether there 558 // are any more events found. In case of a retrieval or parsing error, false is 559 // returned and Error() can be queried for the exact failure. 560 func (it *AuthControllerOwnershipTransferredIterator) Next() bool { 561 // If the iterator failed, stop iterating 562 if it.fail != nil { 563 return false 564 } 565 // If the iterator completed, deliver directly whatever's available 566 if it.done { 567 select { 568 case log := <-it.logs: 569 it.Event = new(AuthControllerOwnershipTransferred) 570 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 571 it.fail = err 572 return false 573 } 574 it.Event.Raw = log 575 return true 576 577 default: 578 return false 579 } 580 } 581 // Iterator still in progress, wait for either a data or an error event 582 select { 583 case log := <-it.logs: 584 it.Event = new(AuthControllerOwnershipTransferred) 585 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 586 it.fail = err 587 return false 588 } 589 it.Event.Raw = log 590 return true 591 592 case err := <-it.sub.Err(): 593 it.done = true 594 it.fail = err 595 return it.Next() 596 } 597 } 598 599 // Error returns any retrieval or parsing error occurred during filtering. 600 func (it *AuthControllerOwnershipTransferredIterator) Error() error { 601 return it.fail 602 } 603 604 // Close terminates the iteration process, releasing any pending underlying 605 // resources. 606 func (it *AuthControllerOwnershipTransferredIterator) Close() error { 607 it.sub.Unsubscribe() 608 return nil 609 } 610 611 // AuthControllerOwnershipTransferred represents a OwnershipTransferred event raised by the AuthController contract. 612 type AuthControllerOwnershipTransferred struct { 613 PreviousOwner common.Address 614 NewOwner common.Address 615 Raw types.Log // Blockchain specific contextual infos 616 } 617 618 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 619 // 620 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 621 func (_AuthController *AuthControllerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*AuthControllerOwnershipTransferredIterator, error) { 622 623 var previousOwnerRule []interface{} 624 for _, previousOwnerItem := range previousOwner { 625 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 626 } 627 var newOwnerRule []interface{} 628 for _, newOwnerItem := range newOwner { 629 newOwnerRule = append(newOwnerRule, newOwnerItem) 630 } 631 632 logs, sub, err := _AuthController.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 633 if err != nil { 634 return nil, err 635 } 636 return &AuthControllerOwnershipTransferredIterator{contract: _AuthController.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 637 } 638 639 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 640 // 641 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 642 func (_AuthController *AuthControllerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *AuthControllerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 643 644 var previousOwnerRule []interface{} 645 for _, previousOwnerItem := range previousOwner { 646 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 647 } 648 var newOwnerRule []interface{} 649 for _, newOwnerItem := range newOwner { 650 newOwnerRule = append(newOwnerRule, newOwnerItem) 651 } 652 653 logs, sub, err := _AuthController.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 654 if err != nil { 655 return nil, err 656 } 657 return event.NewSubscription(func(quit <-chan struct{}) error { 658 defer sub.Unsubscribe() 659 for { 660 select { 661 case log := <-logs: 662 // New log arrived, parse the event and forward to the user 663 event := new(AuthControllerOwnershipTransferred) 664 if err := _AuthController.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 665 return err 666 } 667 event.Raw = log 668 669 select { 670 case sink <- event: 671 case err := <-sub.Err(): 672 return err 673 case <-quit: 674 return nil 675 } 676 case err := <-sub.Err(): 677 return err 678 case <-quit: 679 return nil 680 } 681 } 682 }), nil 683 } 684 685 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 686 // 687 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 688 func (_AuthController *AuthControllerFilterer) ParseOwnershipTransferred(log types.Log) (*AuthControllerOwnershipTransferred, error) { 689 event := new(AuthControllerOwnershipTransferred) 690 if err := _AuthController.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 691 return nil, err 692 } 693 return event, nil 694 } 695 696 // ContextABI is the input ABI used to generate the binding from. 697 const ContextABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]" 698 699 // Context is an auto generated Go binding around an Ethereum contract. 700 type Context struct { 701 ContextCaller // Read-only binding to the contract 702 ContextTransactor // Write-only binding to the contract 703 ContextFilterer // Log filterer for contract events 704 } 705 706 // ContextCaller is an auto generated read-only Go binding around an Ethereum contract. 707 type ContextCaller struct { 708 contract *bind.BoundContract // Generic contract wrapper for the low level calls 709 } 710 711 // ContextTransactor is an auto generated write-only Go binding around an Ethereum contract. 712 type ContextTransactor struct { 713 contract *bind.BoundContract // Generic contract wrapper for the low level calls 714 } 715 716 // ContextFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 717 type ContextFilterer struct { 718 contract *bind.BoundContract // Generic contract wrapper for the low level calls 719 } 720 721 // ContextSession is an auto generated Go binding around an Ethereum contract, 722 // with pre-set call and transact options. 723 type ContextSession struct { 724 Contract *Context // Generic contract binding to set the session for 725 CallOpts bind.CallOpts // Call options to use throughout this session 726 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 727 } 728 729 // ContextCallerSession is an auto generated read-only Go binding around an Ethereum contract, 730 // with pre-set call options. 731 type ContextCallerSession struct { 732 Contract *ContextCaller // Generic contract caller binding to set the session for 733 CallOpts bind.CallOpts // Call options to use throughout this session 734 } 735 736 // ContextTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 737 // with pre-set transact options. 738 type ContextTransactorSession struct { 739 Contract *ContextTransactor // Generic contract transactor binding to set the session for 740 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 741 } 742 743 // ContextRaw is an auto generated low-level Go binding around an Ethereum contract. 744 type ContextRaw struct { 745 Contract *Context // Generic contract binding to access the raw methods on 746 } 747 748 // ContextCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 749 type ContextCallerRaw struct { 750 Contract *ContextCaller // Generic read-only contract binding to access the raw methods on 751 } 752 753 // ContextTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 754 type ContextTransactorRaw struct { 755 Contract *ContextTransactor // Generic write-only contract binding to access the raw methods on 756 } 757 758 // NewContext creates a new instance of Context, bound to a specific deployed contract. 759 func NewContext(address common.Address, backend bind.ContractBackend) (*Context, error) { 760 contract, err := bindContext(address, backend, backend, backend) 761 if err != nil { 762 return nil, err 763 } 764 return &Context{ContextCaller: ContextCaller{contract: contract}, ContextTransactor: ContextTransactor{contract: contract}, ContextFilterer: ContextFilterer{contract: contract}}, nil 765 } 766 767 // NewContextCaller creates a new read-only instance of Context, bound to a specific deployed contract. 768 func NewContextCaller(address common.Address, caller bind.ContractCaller) (*ContextCaller, error) { 769 contract, err := bindContext(address, caller, nil, nil) 770 if err != nil { 771 return nil, err 772 } 773 return &ContextCaller{contract: contract}, nil 774 } 775 776 // NewContextTransactor creates a new write-only instance of Context, bound to a specific deployed contract. 777 func NewContextTransactor(address common.Address, transactor bind.ContractTransactor) (*ContextTransactor, error) { 778 contract, err := bindContext(address, nil, transactor, nil) 779 if err != nil { 780 return nil, err 781 } 782 return &ContextTransactor{contract: contract}, nil 783 } 784 785 // NewContextFilterer creates a new log filterer instance of Context, bound to a specific deployed contract. 786 func NewContextFilterer(address common.Address, filterer bind.ContractFilterer) (*ContextFilterer, error) { 787 contract, err := bindContext(address, nil, nil, filterer) 788 if err != nil { 789 return nil, err 790 } 791 return &ContextFilterer{contract: contract}, nil 792 } 793 794 // bindContext binds a generic wrapper to an already deployed contract. 795 func bindContext(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 796 parsed, err := abi.JSON(strings.NewReader(ContextABI)) 797 if err != nil { 798 return nil, err 799 } 800 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 801 } 802 803 // Call invokes the (constant) contract method with params as input values and 804 // sets the output to result. The result type might be a single field for simple 805 // returns, a slice of interfaces for anonymous returns and a struct for named 806 // returns. 807 func (_Context *ContextRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 808 return _Context.Contract.ContextCaller.contract.Call(opts, result, method, params...) 809 } 810 811 // Transfer initiates a plain transaction to move funds to the contract, calling 812 // its default method if one is available. 813 func (_Context *ContextRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 814 return _Context.Contract.ContextTransactor.contract.Transfer(opts) 815 } 816 817 // Transact invokes the (paid) contract method with params as input values. 818 func (_Context *ContextRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 819 return _Context.Contract.ContextTransactor.contract.Transact(opts, method, params...) 820 } 821 822 // Call invokes the (constant) contract method with params as input values and 823 // sets the output to result. The result type might be a single field for simple 824 // returns, a slice of interfaces for anonymous returns and a struct for named 825 // returns. 826 func (_Context *ContextCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 827 return _Context.Contract.contract.Call(opts, result, method, params...) 828 } 829 830 // Transfer initiates a plain transaction to move funds to the contract, calling 831 // its default method if one is available. 832 func (_Context *ContextTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 833 return _Context.Contract.contract.Transfer(opts) 834 } 835 836 // Transact invokes the (paid) contract method with params as input values. 837 func (_Context *ContextTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 838 return _Context.Contract.contract.Transact(opts, method, params...) 839 } 840 841 // DSMathABI is the input ABI used to generate the binding from. 842 const DSMathABI = "[]" 843 844 // DSMathBin is the compiled bytecode used for deploying new contracts. 845 var DSMathBin = "0x6080604052348015600f57600080fd5b50603e80601d6000396000f3fe6080604052600080fdfea265627a7a723158201d3383a4efea7d4c911511edcc2240f991199f32cf3b3c855dd9ffb45f3f45a164736f6c634300050c0032" 846 847 // DeployDSMath deploys a new Ethereum contract, binding an instance of DSMath to it. 848 func DeployDSMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *DSMath, error) { 849 parsed, err := abi.JSON(strings.NewReader(DSMathABI)) 850 if err != nil { 851 return common.Address{}, nil, nil, err 852 } 853 854 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(DSMathBin), backend) 855 if err != nil { 856 return common.Address{}, nil, nil, err 857 } 858 return address, tx, &DSMath{DSMathCaller: DSMathCaller{contract: contract}, DSMathTransactor: DSMathTransactor{contract: contract}, DSMathFilterer: DSMathFilterer{contract: contract}}, nil 859 } 860 861 // DSMath is an auto generated Go binding around an Ethereum contract. 862 type DSMath struct { 863 DSMathCaller // Read-only binding to the contract 864 DSMathTransactor // Write-only binding to the contract 865 DSMathFilterer // Log filterer for contract events 866 } 867 868 // DSMathCaller is an auto generated read-only Go binding around an Ethereum contract. 869 type DSMathCaller struct { 870 contract *bind.BoundContract // Generic contract wrapper for the low level calls 871 } 872 873 // DSMathTransactor is an auto generated write-only Go binding around an Ethereum contract. 874 type DSMathTransactor struct { 875 contract *bind.BoundContract // Generic contract wrapper for the low level calls 876 } 877 878 // DSMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 879 type DSMathFilterer struct { 880 contract *bind.BoundContract // Generic contract wrapper for the low level calls 881 } 882 883 // DSMathSession is an auto generated Go binding around an Ethereum contract, 884 // with pre-set call and transact options. 885 type DSMathSession struct { 886 Contract *DSMath // Generic contract binding to set the session for 887 CallOpts bind.CallOpts // Call options to use throughout this session 888 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 889 } 890 891 // DSMathCallerSession is an auto generated read-only Go binding around an Ethereum contract, 892 // with pre-set call options. 893 type DSMathCallerSession struct { 894 Contract *DSMathCaller // Generic contract caller binding to set the session for 895 CallOpts bind.CallOpts // Call options to use throughout this session 896 } 897 898 // DSMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 899 // with pre-set transact options. 900 type DSMathTransactorSession struct { 901 Contract *DSMathTransactor // Generic contract transactor binding to set the session for 902 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 903 } 904 905 // DSMathRaw is an auto generated low-level Go binding around an Ethereum contract. 906 type DSMathRaw struct { 907 Contract *DSMath // Generic contract binding to access the raw methods on 908 } 909 910 // DSMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 911 type DSMathCallerRaw struct { 912 Contract *DSMathCaller // Generic read-only contract binding to access the raw methods on 913 } 914 915 // DSMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 916 type DSMathTransactorRaw struct { 917 Contract *DSMathTransactor // Generic write-only contract binding to access the raw methods on 918 } 919 920 // NewDSMath creates a new instance of DSMath, bound to a specific deployed contract. 921 func NewDSMath(address common.Address, backend bind.ContractBackend) (*DSMath, error) { 922 contract, err := bindDSMath(address, backend, backend, backend) 923 if err != nil { 924 return nil, err 925 } 926 return &DSMath{DSMathCaller: DSMathCaller{contract: contract}, DSMathTransactor: DSMathTransactor{contract: contract}, DSMathFilterer: DSMathFilterer{contract: contract}}, nil 927 } 928 929 // NewDSMathCaller creates a new read-only instance of DSMath, bound to a specific deployed contract. 930 func NewDSMathCaller(address common.Address, caller bind.ContractCaller) (*DSMathCaller, error) { 931 contract, err := bindDSMath(address, caller, nil, nil) 932 if err != nil { 933 return nil, err 934 } 935 return &DSMathCaller{contract: contract}, nil 936 } 937 938 // NewDSMathTransactor creates a new write-only instance of DSMath, bound to a specific deployed contract. 939 func NewDSMathTransactor(address common.Address, transactor bind.ContractTransactor) (*DSMathTransactor, error) { 940 contract, err := bindDSMath(address, nil, transactor, nil) 941 if err != nil { 942 return nil, err 943 } 944 return &DSMathTransactor{contract: contract}, nil 945 } 946 947 // NewDSMathFilterer creates a new log filterer instance of DSMath, bound to a specific deployed contract. 948 func NewDSMathFilterer(address common.Address, filterer bind.ContractFilterer) (*DSMathFilterer, error) { 949 contract, err := bindDSMath(address, nil, nil, filterer) 950 if err != nil { 951 return nil, err 952 } 953 return &DSMathFilterer{contract: contract}, nil 954 } 955 956 // bindDSMath binds a generic wrapper to an already deployed contract. 957 func bindDSMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 958 parsed, err := abi.JSON(strings.NewReader(DSMathABI)) 959 if err != nil { 960 return nil, err 961 } 962 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 963 } 964 965 // Call invokes the (constant) contract method with params as input values and 966 // sets the output to result. The result type might be a single field for simple 967 // returns, a slice of interfaces for anonymous returns and a struct for named 968 // returns. 969 func (_DSMath *DSMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 970 return _DSMath.Contract.DSMathCaller.contract.Call(opts, result, method, params...) 971 } 972 973 // Transfer initiates a plain transaction to move funds to the contract, calling 974 // its default method if one is available. 975 func (_DSMath *DSMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 976 return _DSMath.Contract.DSMathTransactor.contract.Transfer(opts) 977 } 978 979 // Transact invokes the (paid) contract method with params as input values. 980 func (_DSMath *DSMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 981 return _DSMath.Contract.DSMathTransactor.contract.Transact(opts, method, params...) 982 } 983 984 // Call invokes the (constant) contract method with params as input values and 985 // sets the output to result. The result type might be a single field for simple 986 // returns, a slice of interfaces for anonymous returns and a struct for named 987 // returns. 988 func (_DSMath *DSMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 989 return _DSMath.Contract.contract.Call(opts, result, method, params...) 990 } 991 992 // Transfer initiates a plain transaction to move funds to the contract, calling 993 // its default method if one is available. 994 func (_DSMath *DSMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 995 return _DSMath.Contract.contract.Transfer(opts) 996 } 997 998 // Transact invokes the (paid) contract method with params as input values. 999 func (_DSMath *DSMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1000 return _DSMath.Contract.contract.Transact(opts, method, params...) 1001 } 1002 1003 // DepositManagerABI is the input ABI used to generate the binding from. 1004 const DepositManagerABI = "[{\"inputs\":[{\"internalType\":\"contractWTON\",\"name\":\"wton\",\"type\":\"address\"},{\"internalType\":\"contractRootChainRegistryI\",\"name\":\"registry\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"WITHDRAWAL_DELAY\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"depositor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"Deposited\",\"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\":true,\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"depositor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"WithdrawalProcessed\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"address\",\"name\":\"depositor\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"WithdrawalRequested\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"INTERFACE_ID_ON_APPROVE\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"WITHDRAWAL_DELAY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accStaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accStakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"accStakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accUnstaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accUnstakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"accUnstakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isOwner\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"numPendingRequests\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"numRequests\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onApprove\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"pendingUnstaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"pendingUnstakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"pendingUnstakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"bool\",\"name\":\"receiveTON\",\"type\":\"bool\"}],\"name\":\"processRequest\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"n\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"receiveTON\",\"type\":\"bool\"}],\"name\":\"processRequests\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"redeposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"n\",\"type\":\"uint256\"}],\"name\":\"redepositMulti\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"registry\",\"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\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"requestWithdrawal\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"requestWithdrawalAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"contractSeigManagerI\",\"name\":\"seigManager\",\"type\":\"address\"}],\"name\":\"setSeigManager\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"withdrawalRequest\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"withdrawableBlockNumber\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bool\",\"name\":\"processed\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"withdrawalRequestIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"wton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]" 1005 1006 // DepositManagerFuncSigs maps the 4-byte function signature to its string representation. 1007 var DepositManagerFuncSigs = map[string]string{ 1008 "6cd28f9a": "INTERFACE_ID_ON_APPROVE()", 1009 "0ebb172a": "WITHDRAWAL_DELAY()", 1010 "2d2fab94": "accStaked(address,address)", 1011 "0055f5c1": "accStakedAccount(address)", 1012 "e8035ec9": "accStakedRootChain(address)", 1013 "9d91b87b": "accUnstaked(address,address)", 1014 "a3543989": "accUnstakedAccount(address)", 1015 "03dc6510": "accUnstakedRootChain(address)", 1016 "47e7ef24": "deposit(address,uint256)", 1017 "8f32d59b": "isOwner()", 1018 "5c0df46b": "numPendingRequests(address,address)", 1019 "f762eb57": "numRequests(address,address)", 1020 "4273ca16": "onApprove(address,address,uint256,bytes)", 1021 "8da5cb5b": "owner()", 1022 "2638fdf5": "pendingUnstaked(address,address)", 1023 "a0b2a913": "pendingUnstakedAccount(address)", 1024 "a8f3fb98": "pendingUnstakedRootChain(address)", 1025 "c20a44c6": "processRequest(address,bool)", 1026 "fb0713b1": "processRequests(address,uint256,bool)", 1027 "b8bee628": "redeposit(address)", 1028 "445e83b9": "redepositMulti(address,uint256)", 1029 "7b103999": "registry()", 1030 "715018a6": "renounceOwnership()", 1031 "da95ebf7": "requestWithdrawal(address,uint256)", 1032 "6b2160b7": "requestWithdrawalAll(address)", 1033 "6fb7f558": "seigManager()", 1034 "7657f20a": "setSeigManager(address)", 1035 "01ffc9a7": "supportsInterface(bytes4)", 1036 "f2fde38b": "transferOwnership(address)", 1037 "8fbef2d0": "withdrawalRequest(address,address,uint256)", 1038 "c647f26e": "withdrawalRequestIndex(address,address)", 1039 "8d62d949": "wton()", 1040 } 1041 1042 // DepositManagerBin is the compiled bytecode used for deploying new contracts. 1043 var DepositManagerBin = "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" 1044 1045 // DeployDepositManager deploys a new Ethereum contract, binding an instance of DepositManager to it. 1046 func DeployDepositManager(auth *bind.TransactOpts, backend bind.ContractBackend, wton common.Address, registry common.Address, WITHDRAWAL_DELAY *big.Int) (common.Address, *types.Transaction, *DepositManager, error) { 1047 parsed, err := abi.JSON(strings.NewReader(DepositManagerABI)) 1048 if err != nil { 1049 return common.Address{}, nil, nil, err 1050 } 1051 1052 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(DepositManagerBin), backend, wton, registry, WITHDRAWAL_DELAY) 1053 if err != nil { 1054 return common.Address{}, nil, nil, err 1055 } 1056 return address, tx, &DepositManager{DepositManagerCaller: DepositManagerCaller{contract: contract}, DepositManagerTransactor: DepositManagerTransactor{contract: contract}, DepositManagerFilterer: DepositManagerFilterer{contract: contract}}, nil 1057 } 1058 1059 // DepositManager is an auto generated Go binding around an Ethereum contract. 1060 type DepositManager struct { 1061 DepositManagerCaller // Read-only binding to the contract 1062 DepositManagerTransactor // Write-only binding to the contract 1063 DepositManagerFilterer // Log filterer for contract events 1064 } 1065 1066 // DepositManagerCaller is an auto generated read-only Go binding around an Ethereum contract. 1067 type DepositManagerCaller struct { 1068 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1069 } 1070 1071 // DepositManagerTransactor is an auto generated write-only Go binding around an Ethereum contract. 1072 type DepositManagerTransactor struct { 1073 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1074 } 1075 1076 // DepositManagerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 1077 type DepositManagerFilterer struct { 1078 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1079 } 1080 1081 // DepositManagerSession is an auto generated Go binding around an Ethereum contract, 1082 // with pre-set call and transact options. 1083 type DepositManagerSession struct { 1084 Contract *DepositManager // Generic contract binding to set the session for 1085 CallOpts bind.CallOpts // Call options to use throughout this session 1086 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1087 } 1088 1089 // DepositManagerCallerSession is an auto generated read-only Go binding around an Ethereum contract, 1090 // with pre-set call options. 1091 type DepositManagerCallerSession struct { 1092 Contract *DepositManagerCaller // Generic contract caller binding to set the session for 1093 CallOpts bind.CallOpts // Call options to use throughout this session 1094 } 1095 1096 // DepositManagerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 1097 // with pre-set transact options. 1098 type DepositManagerTransactorSession struct { 1099 Contract *DepositManagerTransactor // Generic contract transactor binding to set the session for 1100 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1101 } 1102 1103 // DepositManagerRaw is an auto generated low-level Go binding around an Ethereum contract. 1104 type DepositManagerRaw struct { 1105 Contract *DepositManager // Generic contract binding to access the raw methods on 1106 } 1107 1108 // DepositManagerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 1109 type DepositManagerCallerRaw struct { 1110 Contract *DepositManagerCaller // Generic read-only contract binding to access the raw methods on 1111 } 1112 1113 // DepositManagerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 1114 type DepositManagerTransactorRaw struct { 1115 Contract *DepositManagerTransactor // Generic write-only contract binding to access the raw methods on 1116 } 1117 1118 // NewDepositManager creates a new instance of DepositManager, bound to a specific deployed contract. 1119 func NewDepositManager(address common.Address, backend bind.ContractBackend) (*DepositManager, error) { 1120 contract, err := bindDepositManager(address, backend, backend, backend) 1121 if err != nil { 1122 return nil, err 1123 } 1124 return &DepositManager{DepositManagerCaller: DepositManagerCaller{contract: contract}, DepositManagerTransactor: DepositManagerTransactor{contract: contract}, DepositManagerFilterer: DepositManagerFilterer{contract: contract}}, nil 1125 } 1126 1127 // NewDepositManagerCaller creates a new read-only instance of DepositManager, bound to a specific deployed contract. 1128 func NewDepositManagerCaller(address common.Address, caller bind.ContractCaller) (*DepositManagerCaller, error) { 1129 contract, err := bindDepositManager(address, caller, nil, nil) 1130 if err != nil { 1131 return nil, err 1132 } 1133 return &DepositManagerCaller{contract: contract}, nil 1134 } 1135 1136 // NewDepositManagerTransactor creates a new write-only instance of DepositManager, bound to a specific deployed contract. 1137 func NewDepositManagerTransactor(address common.Address, transactor bind.ContractTransactor) (*DepositManagerTransactor, error) { 1138 contract, err := bindDepositManager(address, nil, transactor, nil) 1139 if err != nil { 1140 return nil, err 1141 } 1142 return &DepositManagerTransactor{contract: contract}, nil 1143 } 1144 1145 // NewDepositManagerFilterer creates a new log filterer instance of DepositManager, bound to a specific deployed contract. 1146 func NewDepositManagerFilterer(address common.Address, filterer bind.ContractFilterer) (*DepositManagerFilterer, error) { 1147 contract, err := bindDepositManager(address, nil, nil, filterer) 1148 if err != nil { 1149 return nil, err 1150 } 1151 return &DepositManagerFilterer{contract: contract}, nil 1152 } 1153 1154 // bindDepositManager binds a generic wrapper to an already deployed contract. 1155 func bindDepositManager(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 1156 parsed, err := abi.JSON(strings.NewReader(DepositManagerABI)) 1157 if err != nil { 1158 return nil, err 1159 } 1160 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 1161 } 1162 1163 // Call invokes the (constant) contract method with params as input values and 1164 // sets the output to result. The result type might be a single field for simple 1165 // returns, a slice of interfaces for anonymous returns and a struct for named 1166 // returns. 1167 func (_DepositManager *DepositManagerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 1168 return _DepositManager.Contract.DepositManagerCaller.contract.Call(opts, result, method, params...) 1169 } 1170 1171 // Transfer initiates a plain transaction to move funds to the contract, calling 1172 // its default method if one is available. 1173 func (_DepositManager *DepositManagerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1174 return _DepositManager.Contract.DepositManagerTransactor.contract.Transfer(opts) 1175 } 1176 1177 // Transact invokes the (paid) contract method with params as input values. 1178 func (_DepositManager *DepositManagerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1179 return _DepositManager.Contract.DepositManagerTransactor.contract.Transact(opts, method, params...) 1180 } 1181 1182 // Call invokes the (constant) contract method with params as input values and 1183 // sets the output to result. The result type might be a single field for simple 1184 // returns, a slice of interfaces for anonymous returns and a struct for named 1185 // returns. 1186 func (_DepositManager *DepositManagerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 1187 return _DepositManager.Contract.contract.Call(opts, result, method, params...) 1188 } 1189 1190 // Transfer initiates a plain transaction to move funds to the contract, calling 1191 // its default method if one is available. 1192 func (_DepositManager *DepositManagerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1193 return _DepositManager.Contract.contract.Transfer(opts) 1194 } 1195 1196 // Transact invokes the (paid) contract method with params as input values. 1197 func (_DepositManager *DepositManagerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1198 return _DepositManager.Contract.contract.Transact(opts, method, params...) 1199 } 1200 1201 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 1202 // 1203 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 1204 func (_DepositManager *DepositManagerCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) { 1205 var ( 1206 ret0 = new([4]byte) 1207 ) 1208 out := ret0 1209 err := _DepositManager.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE") 1210 return *ret0, err 1211 } 1212 1213 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 1214 // 1215 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 1216 func (_DepositManager *DepositManagerSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 1217 return _DepositManager.Contract.INTERFACEIDONAPPROVE(&_DepositManager.CallOpts) 1218 } 1219 1220 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 1221 // 1222 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 1223 func (_DepositManager *DepositManagerCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 1224 return _DepositManager.Contract.INTERFACEIDONAPPROVE(&_DepositManager.CallOpts) 1225 } 1226 1227 // WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a. 1228 // 1229 // Solidity: function WITHDRAWAL_DELAY() constant returns(uint256) 1230 func (_DepositManager *DepositManagerCaller) WITHDRAWALDELAY(opts *bind.CallOpts) (*big.Int, error) { 1231 var ( 1232 ret0 = new(*big.Int) 1233 ) 1234 out := ret0 1235 err := _DepositManager.contract.Call(opts, out, "WITHDRAWAL_DELAY") 1236 return *ret0, err 1237 } 1238 1239 // WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a. 1240 // 1241 // Solidity: function WITHDRAWAL_DELAY() constant returns(uint256) 1242 func (_DepositManager *DepositManagerSession) WITHDRAWALDELAY() (*big.Int, error) { 1243 return _DepositManager.Contract.WITHDRAWALDELAY(&_DepositManager.CallOpts) 1244 } 1245 1246 // WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a. 1247 // 1248 // Solidity: function WITHDRAWAL_DELAY() constant returns(uint256) 1249 func (_DepositManager *DepositManagerCallerSession) WITHDRAWALDELAY() (*big.Int, error) { 1250 return _DepositManager.Contract.WITHDRAWALDELAY(&_DepositManager.CallOpts) 1251 } 1252 1253 // AccStaked is a free data retrieval call binding the contract method 0x2d2fab94. 1254 // 1255 // Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount) 1256 func (_DepositManager *DepositManagerCaller) AccStaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 1257 var ( 1258 ret0 = new(*big.Int) 1259 ) 1260 out := ret0 1261 err := _DepositManager.contract.Call(opts, out, "accStaked", rootchain, account) 1262 return *ret0, err 1263 } 1264 1265 // AccStaked is a free data retrieval call binding the contract method 0x2d2fab94. 1266 // 1267 // Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount) 1268 func (_DepositManager *DepositManagerSession) AccStaked(rootchain common.Address, account common.Address) (*big.Int, error) { 1269 return _DepositManager.Contract.AccStaked(&_DepositManager.CallOpts, rootchain, account) 1270 } 1271 1272 // AccStaked is a free data retrieval call binding the contract method 0x2d2fab94. 1273 // 1274 // Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount) 1275 func (_DepositManager *DepositManagerCallerSession) AccStaked(rootchain common.Address, account common.Address) (*big.Int, error) { 1276 return _DepositManager.Contract.AccStaked(&_DepositManager.CallOpts, rootchain, account) 1277 } 1278 1279 // AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1. 1280 // 1281 // Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount) 1282 func (_DepositManager *DepositManagerCaller) AccStakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 1283 var ( 1284 ret0 = new(*big.Int) 1285 ) 1286 out := ret0 1287 err := _DepositManager.contract.Call(opts, out, "accStakedAccount", account) 1288 return *ret0, err 1289 } 1290 1291 // AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1. 1292 // 1293 // Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount) 1294 func (_DepositManager *DepositManagerSession) AccStakedAccount(account common.Address) (*big.Int, error) { 1295 return _DepositManager.Contract.AccStakedAccount(&_DepositManager.CallOpts, account) 1296 } 1297 1298 // AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1. 1299 // 1300 // Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount) 1301 func (_DepositManager *DepositManagerCallerSession) AccStakedAccount(account common.Address) (*big.Int, error) { 1302 return _DepositManager.Contract.AccStakedAccount(&_DepositManager.CallOpts, account) 1303 } 1304 1305 // AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9. 1306 // 1307 // Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 1308 func (_DepositManager *DepositManagerCaller) AccStakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) { 1309 var ( 1310 ret0 = new(*big.Int) 1311 ) 1312 out := ret0 1313 err := _DepositManager.contract.Call(opts, out, "accStakedRootChain", rootchain) 1314 return *ret0, err 1315 } 1316 1317 // AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9. 1318 // 1319 // Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 1320 func (_DepositManager *DepositManagerSession) AccStakedRootChain(rootchain common.Address) (*big.Int, error) { 1321 return _DepositManager.Contract.AccStakedRootChain(&_DepositManager.CallOpts, rootchain) 1322 } 1323 1324 // AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9. 1325 // 1326 // Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 1327 func (_DepositManager *DepositManagerCallerSession) AccStakedRootChain(rootchain common.Address) (*big.Int, error) { 1328 return _DepositManager.Contract.AccStakedRootChain(&_DepositManager.CallOpts, rootchain) 1329 } 1330 1331 // AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b. 1332 // 1333 // Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount) 1334 func (_DepositManager *DepositManagerCaller) AccUnstaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 1335 var ( 1336 ret0 = new(*big.Int) 1337 ) 1338 out := ret0 1339 err := _DepositManager.contract.Call(opts, out, "accUnstaked", rootchain, account) 1340 return *ret0, err 1341 } 1342 1343 // AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b. 1344 // 1345 // Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount) 1346 func (_DepositManager *DepositManagerSession) AccUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) { 1347 return _DepositManager.Contract.AccUnstaked(&_DepositManager.CallOpts, rootchain, account) 1348 } 1349 1350 // AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b. 1351 // 1352 // Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount) 1353 func (_DepositManager *DepositManagerCallerSession) AccUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) { 1354 return _DepositManager.Contract.AccUnstaked(&_DepositManager.CallOpts, rootchain, account) 1355 } 1356 1357 // AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989. 1358 // 1359 // Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount) 1360 func (_DepositManager *DepositManagerCaller) AccUnstakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 1361 var ( 1362 ret0 = new(*big.Int) 1363 ) 1364 out := ret0 1365 err := _DepositManager.contract.Call(opts, out, "accUnstakedAccount", account) 1366 return *ret0, err 1367 } 1368 1369 // AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989. 1370 // 1371 // Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount) 1372 func (_DepositManager *DepositManagerSession) AccUnstakedAccount(account common.Address) (*big.Int, error) { 1373 return _DepositManager.Contract.AccUnstakedAccount(&_DepositManager.CallOpts, account) 1374 } 1375 1376 // AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989. 1377 // 1378 // Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount) 1379 func (_DepositManager *DepositManagerCallerSession) AccUnstakedAccount(account common.Address) (*big.Int, error) { 1380 return _DepositManager.Contract.AccUnstakedAccount(&_DepositManager.CallOpts, account) 1381 } 1382 1383 // AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510. 1384 // 1385 // Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 1386 func (_DepositManager *DepositManagerCaller) AccUnstakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) { 1387 var ( 1388 ret0 = new(*big.Int) 1389 ) 1390 out := ret0 1391 err := _DepositManager.contract.Call(opts, out, "accUnstakedRootChain", rootchain) 1392 return *ret0, err 1393 } 1394 1395 // AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510. 1396 // 1397 // Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 1398 func (_DepositManager *DepositManagerSession) AccUnstakedRootChain(rootchain common.Address) (*big.Int, error) { 1399 return _DepositManager.Contract.AccUnstakedRootChain(&_DepositManager.CallOpts, rootchain) 1400 } 1401 1402 // AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510. 1403 // 1404 // Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 1405 func (_DepositManager *DepositManagerCallerSession) AccUnstakedRootChain(rootchain common.Address) (*big.Int, error) { 1406 return _DepositManager.Contract.AccUnstakedRootChain(&_DepositManager.CallOpts, rootchain) 1407 } 1408 1409 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 1410 // 1411 // Solidity: function isOwner() constant returns(bool) 1412 func (_DepositManager *DepositManagerCaller) IsOwner(opts *bind.CallOpts) (bool, error) { 1413 var ( 1414 ret0 = new(bool) 1415 ) 1416 out := ret0 1417 err := _DepositManager.contract.Call(opts, out, "isOwner") 1418 return *ret0, err 1419 } 1420 1421 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 1422 // 1423 // Solidity: function isOwner() constant returns(bool) 1424 func (_DepositManager *DepositManagerSession) IsOwner() (bool, error) { 1425 return _DepositManager.Contract.IsOwner(&_DepositManager.CallOpts) 1426 } 1427 1428 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 1429 // 1430 // Solidity: function isOwner() constant returns(bool) 1431 func (_DepositManager *DepositManagerCallerSession) IsOwner() (bool, error) { 1432 return _DepositManager.Contract.IsOwner(&_DepositManager.CallOpts) 1433 } 1434 1435 // NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b. 1436 // 1437 // Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256) 1438 func (_DepositManager *DepositManagerCaller) NumPendingRequests(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 1439 var ( 1440 ret0 = new(*big.Int) 1441 ) 1442 out := ret0 1443 err := _DepositManager.contract.Call(opts, out, "numPendingRequests", rootchain, account) 1444 return *ret0, err 1445 } 1446 1447 // NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b. 1448 // 1449 // Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256) 1450 func (_DepositManager *DepositManagerSession) NumPendingRequests(rootchain common.Address, account common.Address) (*big.Int, error) { 1451 return _DepositManager.Contract.NumPendingRequests(&_DepositManager.CallOpts, rootchain, account) 1452 } 1453 1454 // NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b. 1455 // 1456 // Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256) 1457 func (_DepositManager *DepositManagerCallerSession) NumPendingRequests(rootchain common.Address, account common.Address) (*big.Int, error) { 1458 return _DepositManager.Contract.NumPendingRequests(&_DepositManager.CallOpts, rootchain, account) 1459 } 1460 1461 // NumRequests is a free data retrieval call binding the contract method 0xf762eb57. 1462 // 1463 // Solidity: function numRequests(address rootchain, address account) constant returns(uint256) 1464 func (_DepositManager *DepositManagerCaller) NumRequests(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 1465 var ( 1466 ret0 = new(*big.Int) 1467 ) 1468 out := ret0 1469 err := _DepositManager.contract.Call(opts, out, "numRequests", rootchain, account) 1470 return *ret0, err 1471 } 1472 1473 // NumRequests is a free data retrieval call binding the contract method 0xf762eb57. 1474 // 1475 // Solidity: function numRequests(address rootchain, address account) constant returns(uint256) 1476 func (_DepositManager *DepositManagerSession) NumRequests(rootchain common.Address, account common.Address) (*big.Int, error) { 1477 return _DepositManager.Contract.NumRequests(&_DepositManager.CallOpts, rootchain, account) 1478 } 1479 1480 // NumRequests is a free data retrieval call binding the contract method 0xf762eb57. 1481 // 1482 // Solidity: function numRequests(address rootchain, address account) constant returns(uint256) 1483 func (_DepositManager *DepositManagerCallerSession) NumRequests(rootchain common.Address, account common.Address) (*big.Int, error) { 1484 return _DepositManager.Contract.NumRequests(&_DepositManager.CallOpts, rootchain, account) 1485 } 1486 1487 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 1488 // 1489 // Solidity: function owner() constant returns(address) 1490 func (_DepositManager *DepositManagerCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 1491 var ( 1492 ret0 = new(common.Address) 1493 ) 1494 out := ret0 1495 err := _DepositManager.contract.Call(opts, out, "owner") 1496 return *ret0, err 1497 } 1498 1499 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 1500 // 1501 // Solidity: function owner() constant returns(address) 1502 func (_DepositManager *DepositManagerSession) Owner() (common.Address, error) { 1503 return _DepositManager.Contract.Owner(&_DepositManager.CallOpts) 1504 } 1505 1506 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 1507 // 1508 // Solidity: function owner() constant returns(address) 1509 func (_DepositManager *DepositManagerCallerSession) Owner() (common.Address, error) { 1510 return _DepositManager.Contract.Owner(&_DepositManager.CallOpts) 1511 } 1512 1513 // PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5. 1514 // 1515 // Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount) 1516 func (_DepositManager *DepositManagerCaller) PendingUnstaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 1517 var ( 1518 ret0 = new(*big.Int) 1519 ) 1520 out := ret0 1521 err := _DepositManager.contract.Call(opts, out, "pendingUnstaked", rootchain, account) 1522 return *ret0, err 1523 } 1524 1525 // PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5. 1526 // 1527 // Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount) 1528 func (_DepositManager *DepositManagerSession) PendingUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) { 1529 return _DepositManager.Contract.PendingUnstaked(&_DepositManager.CallOpts, rootchain, account) 1530 } 1531 1532 // PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5. 1533 // 1534 // Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount) 1535 func (_DepositManager *DepositManagerCallerSession) PendingUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) { 1536 return _DepositManager.Contract.PendingUnstaked(&_DepositManager.CallOpts, rootchain, account) 1537 } 1538 1539 // PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913. 1540 // 1541 // Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount) 1542 func (_DepositManager *DepositManagerCaller) PendingUnstakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 1543 var ( 1544 ret0 = new(*big.Int) 1545 ) 1546 out := ret0 1547 err := _DepositManager.contract.Call(opts, out, "pendingUnstakedAccount", account) 1548 return *ret0, err 1549 } 1550 1551 // PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913. 1552 // 1553 // Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount) 1554 func (_DepositManager *DepositManagerSession) PendingUnstakedAccount(account common.Address) (*big.Int, error) { 1555 return _DepositManager.Contract.PendingUnstakedAccount(&_DepositManager.CallOpts, account) 1556 } 1557 1558 // PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913. 1559 // 1560 // Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount) 1561 func (_DepositManager *DepositManagerCallerSession) PendingUnstakedAccount(account common.Address) (*big.Int, error) { 1562 return _DepositManager.Contract.PendingUnstakedAccount(&_DepositManager.CallOpts, account) 1563 } 1564 1565 // PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98. 1566 // 1567 // Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 1568 func (_DepositManager *DepositManagerCaller) PendingUnstakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) { 1569 var ( 1570 ret0 = new(*big.Int) 1571 ) 1572 out := ret0 1573 err := _DepositManager.contract.Call(opts, out, "pendingUnstakedRootChain", rootchain) 1574 return *ret0, err 1575 } 1576 1577 // PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98. 1578 // 1579 // Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 1580 func (_DepositManager *DepositManagerSession) PendingUnstakedRootChain(rootchain common.Address) (*big.Int, error) { 1581 return _DepositManager.Contract.PendingUnstakedRootChain(&_DepositManager.CallOpts, rootchain) 1582 } 1583 1584 // PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98. 1585 // 1586 // Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 1587 func (_DepositManager *DepositManagerCallerSession) PendingUnstakedRootChain(rootchain common.Address) (*big.Int, error) { 1588 return _DepositManager.Contract.PendingUnstakedRootChain(&_DepositManager.CallOpts, rootchain) 1589 } 1590 1591 // Registry is a free data retrieval call binding the contract method 0x7b103999. 1592 // 1593 // Solidity: function registry() constant returns(address) 1594 func (_DepositManager *DepositManagerCaller) Registry(opts *bind.CallOpts) (common.Address, error) { 1595 var ( 1596 ret0 = new(common.Address) 1597 ) 1598 out := ret0 1599 err := _DepositManager.contract.Call(opts, out, "registry") 1600 return *ret0, err 1601 } 1602 1603 // Registry is a free data retrieval call binding the contract method 0x7b103999. 1604 // 1605 // Solidity: function registry() constant returns(address) 1606 func (_DepositManager *DepositManagerSession) Registry() (common.Address, error) { 1607 return _DepositManager.Contract.Registry(&_DepositManager.CallOpts) 1608 } 1609 1610 // Registry is a free data retrieval call binding the contract method 0x7b103999. 1611 // 1612 // Solidity: function registry() constant returns(address) 1613 func (_DepositManager *DepositManagerCallerSession) Registry() (common.Address, error) { 1614 return _DepositManager.Contract.Registry(&_DepositManager.CallOpts) 1615 } 1616 1617 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 1618 // 1619 // Solidity: function seigManager() constant returns(address) 1620 func (_DepositManager *DepositManagerCaller) SeigManager(opts *bind.CallOpts) (common.Address, error) { 1621 var ( 1622 ret0 = new(common.Address) 1623 ) 1624 out := ret0 1625 err := _DepositManager.contract.Call(opts, out, "seigManager") 1626 return *ret0, err 1627 } 1628 1629 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 1630 // 1631 // Solidity: function seigManager() constant returns(address) 1632 func (_DepositManager *DepositManagerSession) SeigManager() (common.Address, error) { 1633 return _DepositManager.Contract.SeigManager(&_DepositManager.CallOpts) 1634 } 1635 1636 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 1637 // 1638 // Solidity: function seigManager() constant returns(address) 1639 func (_DepositManager *DepositManagerCallerSession) SeigManager() (common.Address, error) { 1640 return _DepositManager.Contract.SeigManager(&_DepositManager.CallOpts) 1641 } 1642 1643 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 1644 // 1645 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 1646 func (_DepositManager *DepositManagerCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { 1647 var ( 1648 ret0 = new(bool) 1649 ) 1650 out := ret0 1651 err := _DepositManager.contract.Call(opts, out, "supportsInterface", interfaceId) 1652 return *ret0, err 1653 } 1654 1655 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 1656 // 1657 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 1658 func (_DepositManager *DepositManagerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { 1659 return _DepositManager.Contract.SupportsInterface(&_DepositManager.CallOpts, interfaceId) 1660 } 1661 1662 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 1663 // 1664 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 1665 func (_DepositManager *DepositManagerCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { 1666 return _DepositManager.Contract.SupportsInterface(&_DepositManager.CallOpts, interfaceId) 1667 } 1668 1669 // WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0. 1670 // 1671 // Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed) 1672 func (_DepositManager *DepositManagerCaller) WithdrawalRequest(opts *bind.CallOpts, rootchain common.Address, account common.Address, index *big.Int) (struct { 1673 WithdrawableBlockNumber *big.Int 1674 Amount *big.Int 1675 Processed bool 1676 }, error) { 1677 ret := new(struct { 1678 WithdrawableBlockNumber *big.Int 1679 Amount *big.Int 1680 Processed bool 1681 }) 1682 out := ret 1683 err := _DepositManager.contract.Call(opts, out, "withdrawalRequest", rootchain, account, index) 1684 return *ret, err 1685 } 1686 1687 // WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0. 1688 // 1689 // Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed) 1690 func (_DepositManager *DepositManagerSession) WithdrawalRequest(rootchain common.Address, account common.Address, index *big.Int) (struct { 1691 WithdrawableBlockNumber *big.Int 1692 Amount *big.Int 1693 Processed bool 1694 }, error) { 1695 return _DepositManager.Contract.WithdrawalRequest(&_DepositManager.CallOpts, rootchain, account, index) 1696 } 1697 1698 // WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0. 1699 // 1700 // Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed) 1701 func (_DepositManager *DepositManagerCallerSession) WithdrawalRequest(rootchain common.Address, account common.Address, index *big.Int) (struct { 1702 WithdrawableBlockNumber *big.Int 1703 Amount *big.Int 1704 Processed bool 1705 }, error) { 1706 return _DepositManager.Contract.WithdrawalRequest(&_DepositManager.CallOpts, rootchain, account, index) 1707 } 1708 1709 // WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e. 1710 // 1711 // Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index) 1712 func (_DepositManager *DepositManagerCaller) WithdrawalRequestIndex(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 1713 var ( 1714 ret0 = new(*big.Int) 1715 ) 1716 out := ret0 1717 err := _DepositManager.contract.Call(opts, out, "withdrawalRequestIndex", rootchain, account) 1718 return *ret0, err 1719 } 1720 1721 // WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e. 1722 // 1723 // Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index) 1724 func (_DepositManager *DepositManagerSession) WithdrawalRequestIndex(rootchain common.Address, account common.Address) (*big.Int, error) { 1725 return _DepositManager.Contract.WithdrawalRequestIndex(&_DepositManager.CallOpts, rootchain, account) 1726 } 1727 1728 // WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e. 1729 // 1730 // Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index) 1731 func (_DepositManager *DepositManagerCallerSession) WithdrawalRequestIndex(rootchain common.Address, account common.Address) (*big.Int, error) { 1732 return _DepositManager.Contract.WithdrawalRequestIndex(&_DepositManager.CallOpts, rootchain, account) 1733 } 1734 1735 // Wton is a free data retrieval call binding the contract method 0x8d62d949. 1736 // 1737 // Solidity: function wton() constant returns(address) 1738 func (_DepositManager *DepositManagerCaller) Wton(opts *bind.CallOpts) (common.Address, error) { 1739 var ( 1740 ret0 = new(common.Address) 1741 ) 1742 out := ret0 1743 err := _DepositManager.contract.Call(opts, out, "wton") 1744 return *ret0, err 1745 } 1746 1747 // Wton is a free data retrieval call binding the contract method 0x8d62d949. 1748 // 1749 // Solidity: function wton() constant returns(address) 1750 func (_DepositManager *DepositManagerSession) Wton() (common.Address, error) { 1751 return _DepositManager.Contract.Wton(&_DepositManager.CallOpts) 1752 } 1753 1754 // Wton is a free data retrieval call binding the contract method 0x8d62d949. 1755 // 1756 // Solidity: function wton() constant returns(address) 1757 func (_DepositManager *DepositManagerCallerSession) Wton() (common.Address, error) { 1758 return _DepositManager.Contract.Wton(&_DepositManager.CallOpts) 1759 } 1760 1761 // Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. 1762 // 1763 // Solidity: function deposit(address rootchain, uint256 amount) returns(bool) 1764 func (_DepositManager *DepositManagerTransactor) Deposit(opts *bind.TransactOpts, rootchain common.Address, amount *big.Int) (*types.Transaction, error) { 1765 return _DepositManager.contract.Transact(opts, "deposit", rootchain, amount) 1766 } 1767 1768 // Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. 1769 // 1770 // Solidity: function deposit(address rootchain, uint256 amount) returns(bool) 1771 func (_DepositManager *DepositManagerSession) Deposit(rootchain common.Address, amount *big.Int) (*types.Transaction, error) { 1772 return _DepositManager.Contract.Deposit(&_DepositManager.TransactOpts, rootchain, amount) 1773 } 1774 1775 // Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. 1776 // 1777 // Solidity: function deposit(address rootchain, uint256 amount) returns(bool) 1778 func (_DepositManager *DepositManagerTransactorSession) Deposit(rootchain common.Address, amount *big.Int) (*types.Transaction, error) { 1779 return _DepositManager.Contract.Deposit(&_DepositManager.TransactOpts, rootchain, amount) 1780 } 1781 1782 // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16. 1783 // 1784 // Solidity: function onApprove(address owner, address spender, uint256 amount, bytes data) returns(bool) 1785 func (_DepositManager *DepositManagerTransactor) OnApprove(opts *bind.TransactOpts, owner common.Address, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 1786 return _DepositManager.contract.Transact(opts, "onApprove", owner, spender, amount, data) 1787 } 1788 1789 // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16. 1790 // 1791 // Solidity: function onApprove(address owner, address spender, uint256 amount, bytes data) returns(bool) 1792 func (_DepositManager *DepositManagerSession) OnApprove(owner common.Address, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 1793 return _DepositManager.Contract.OnApprove(&_DepositManager.TransactOpts, owner, spender, amount, data) 1794 } 1795 1796 // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16. 1797 // 1798 // Solidity: function onApprove(address owner, address spender, uint256 amount, bytes data) returns(bool) 1799 func (_DepositManager *DepositManagerTransactorSession) OnApprove(owner common.Address, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 1800 return _DepositManager.Contract.OnApprove(&_DepositManager.TransactOpts, owner, spender, amount, data) 1801 } 1802 1803 // ProcessRequest is a paid mutator transaction binding the contract method 0xc20a44c6. 1804 // 1805 // Solidity: function processRequest(address rootchain, bool receiveTON) returns(bool) 1806 func (_DepositManager *DepositManagerTransactor) ProcessRequest(opts *bind.TransactOpts, rootchain common.Address, receiveTON bool) (*types.Transaction, error) { 1807 return _DepositManager.contract.Transact(opts, "processRequest", rootchain, receiveTON) 1808 } 1809 1810 // ProcessRequest is a paid mutator transaction binding the contract method 0xc20a44c6. 1811 // 1812 // Solidity: function processRequest(address rootchain, bool receiveTON) returns(bool) 1813 func (_DepositManager *DepositManagerSession) ProcessRequest(rootchain common.Address, receiveTON bool) (*types.Transaction, error) { 1814 return _DepositManager.Contract.ProcessRequest(&_DepositManager.TransactOpts, rootchain, receiveTON) 1815 } 1816 1817 // ProcessRequest is a paid mutator transaction binding the contract method 0xc20a44c6. 1818 // 1819 // Solidity: function processRequest(address rootchain, bool receiveTON) returns(bool) 1820 func (_DepositManager *DepositManagerTransactorSession) ProcessRequest(rootchain common.Address, receiveTON bool) (*types.Transaction, error) { 1821 return _DepositManager.Contract.ProcessRequest(&_DepositManager.TransactOpts, rootchain, receiveTON) 1822 } 1823 1824 // ProcessRequests is a paid mutator transaction binding the contract method 0xfb0713b1. 1825 // 1826 // Solidity: function processRequests(address rootchain, uint256 n, bool receiveTON) returns(bool) 1827 func (_DepositManager *DepositManagerTransactor) ProcessRequests(opts *bind.TransactOpts, rootchain common.Address, n *big.Int, receiveTON bool) (*types.Transaction, error) { 1828 return _DepositManager.contract.Transact(opts, "processRequests", rootchain, n, receiveTON) 1829 } 1830 1831 // ProcessRequests is a paid mutator transaction binding the contract method 0xfb0713b1. 1832 // 1833 // Solidity: function processRequests(address rootchain, uint256 n, bool receiveTON) returns(bool) 1834 func (_DepositManager *DepositManagerSession) ProcessRequests(rootchain common.Address, n *big.Int, receiveTON bool) (*types.Transaction, error) { 1835 return _DepositManager.Contract.ProcessRequests(&_DepositManager.TransactOpts, rootchain, n, receiveTON) 1836 } 1837 1838 // ProcessRequests is a paid mutator transaction binding the contract method 0xfb0713b1. 1839 // 1840 // Solidity: function processRequests(address rootchain, uint256 n, bool receiveTON) returns(bool) 1841 func (_DepositManager *DepositManagerTransactorSession) ProcessRequests(rootchain common.Address, n *big.Int, receiveTON bool) (*types.Transaction, error) { 1842 return _DepositManager.Contract.ProcessRequests(&_DepositManager.TransactOpts, rootchain, n, receiveTON) 1843 } 1844 1845 // Redeposit is a paid mutator transaction binding the contract method 0xb8bee628. 1846 // 1847 // Solidity: function redeposit(address rootchain) returns(bool) 1848 func (_DepositManager *DepositManagerTransactor) Redeposit(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) { 1849 return _DepositManager.contract.Transact(opts, "redeposit", rootchain) 1850 } 1851 1852 // Redeposit is a paid mutator transaction binding the contract method 0xb8bee628. 1853 // 1854 // Solidity: function redeposit(address rootchain) returns(bool) 1855 func (_DepositManager *DepositManagerSession) Redeposit(rootchain common.Address) (*types.Transaction, error) { 1856 return _DepositManager.Contract.Redeposit(&_DepositManager.TransactOpts, rootchain) 1857 } 1858 1859 // Redeposit is a paid mutator transaction binding the contract method 0xb8bee628. 1860 // 1861 // Solidity: function redeposit(address rootchain) returns(bool) 1862 func (_DepositManager *DepositManagerTransactorSession) Redeposit(rootchain common.Address) (*types.Transaction, error) { 1863 return _DepositManager.Contract.Redeposit(&_DepositManager.TransactOpts, rootchain) 1864 } 1865 1866 // RedepositMulti is a paid mutator transaction binding the contract method 0x445e83b9. 1867 // 1868 // Solidity: function redepositMulti(address rootchain, uint256 n) returns(bool) 1869 func (_DepositManager *DepositManagerTransactor) RedepositMulti(opts *bind.TransactOpts, rootchain common.Address, n *big.Int) (*types.Transaction, error) { 1870 return _DepositManager.contract.Transact(opts, "redepositMulti", rootchain, n) 1871 } 1872 1873 // RedepositMulti is a paid mutator transaction binding the contract method 0x445e83b9. 1874 // 1875 // Solidity: function redepositMulti(address rootchain, uint256 n) returns(bool) 1876 func (_DepositManager *DepositManagerSession) RedepositMulti(rootchain common.Address, n *big.Int) (*types.Transaction, error) { 1877 return _DepositManager.Contract.RedepositMulti(&_DepositManager.TransactOpts, rootchain, n) 1878 } 1879 1880 // RedepositMulti is a paid mutator transaction binding the contract method 0x445e83b9. 1881 // 1882 // Solidity: function redepositMulti(address rootchain, uint256 n) returns(bool) 1883 func (_DepositManager *DepositManagerTransactorSession) RedepositMulti(rootchain common.Address, n *big.Int) (*types.Transaction, error) { 1884 return _DepositManager.Contract.RedepositMulti(&_DepositManager.TransactOpts, rootchain, n) 1885 } 1886 1887 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 1888 // 1889 // Solidity: function renounceOwnership() returns() 1890 func (_DepositManager *DepositManagerTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { 1891 return _DepositManager.contract.Transact(opts, "renounceOwnership") 1892 } 1893 1894 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 1895 // 1896 // Solidity: function renounceOwnership() returns() 1897 func (_DepositManager *DepositManagerSession) RenounceOwnership() (*types.Transaction, error) { 1898 return _DepositManager.Contract.RenounceOwnership(&_DepositManager.TransactOpts) 1899 } 1900 1901 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 1902 // 1903 // Solidity: function renounceOwnership() returns() 1904 func (_DepositManager *DepositManagerTransactorSession) RenounceOwnership() (*types.Transaction, error) { 1905 return _DepositManager.Contract.RenounceOwnership(&_DepositManager.TransactOpts) 1906 } 1907 1908 // RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7. 1909 // 1910 // Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool) 1911 func (_DepositManager *DepositManagerTransactor) RequestWithdrawal(opts *bind.TransactOpts, rootchain common.Address, amount *big.Int) (*types.Transaction, error) { 1912 return _DepositManager.contract.Transact(opts, "requestWithdrawal", rootchain, amount) 1913 } 1914 1915 // RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7. 1916 // 1917 // Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool) 1918 func (_DepositManager *DepositManagerSession) RequestWithdrawal(rootchain common.Address, amount *big.Int) (*types.Transaction, error) { 1919 return _DepositManager.Contract.RequestWithdrawal(&_DepositManager.TransactOpts, rootchain, amount) 1920 } 1921 1922 // RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7. 1923 // 1924 // Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool) 1925 func (_DepositManager *DepositManagerTransactorSession) RequestWithdrawal(rootchain common.Address, amount *big.Int) (*types.Transaction, error) { 1926 return _DepositManager.Contract.RequestWithdrawal(&_DepositManager.TransactOpts, rootchain, amount) 1927 } 1928 1929 // RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7. 1930 // 1931 // Solidity: function requestWithdrawalAll(address rootchain) returns(bool) 1932 func (_DepositManager *DepositManagerTransactor) RequestWithdrawalAll(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) { 1933 return _DepositManager.contract.Transact(opts, "requestWithdrawalAll", rootchain) 1934 } 1935 1936 // RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7. 1937 // 1938 // Solidity: function requestWithdrawalAll(address rootchain) returns(bool) 1939 func (_DepositManager *DepositManagerSession) RequestWithdrawalAll(rootchain common.Address) (*types.Transaction, error) { 1940 return _DepositManager.Contract.RequestWithdrawalAll(&_DepositManager.TransactOpts, rootchain) 1941 } 1942 1943 // RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7. 1944 // 1945 // Solidity: function requestWithdrawalAll(address rootchain) returns(bool) 1946 func (_DepositManager *DepositManagerTransactorSession) RequestWithdrawalAll(rootchain common.Address) (*types.Transaction, error) { 1947 return _DepositManager.Contract.RequestWithdrawalAll(&_DepositManager.TransactOpts, rootchain) 1948 } 1949 1950 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 1951 // 1952 // Solidity: function setSeigManager(address seigManager) returns() 1953 func (_DepositManager *DepositManagerTransactor) SetSeigManager(opts *bind.TransactOpts, seigManager common.Address) (*types.Transaction, error) { 1954 return _DepositManager.contract.Transact(opts, "setSeigManager", seigManager) 1955 } 1956 1957 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 1958 // 1959 // Solidity: function setSeigManager(address seigManager) returns() 1960 func (_DepositManager *DepositManagerSession) SetSeigManager(seigManager common.Address) (*types.Transaction, error) { 1961 return _DepositManager.Contract.SetSeigManager(&_DepositManager.TransactOpts, seigManager) 1962 } 1963 1964 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 1965 // 1966 // Solidity: function setSeigManager(address seigManager) returns() 1967 func (_DepositManager *DepositManagerTransactorSession) SetSeigManager(seigManager common.Address) (*types.Transaction, error) { 1968 return _DepositManager.Contract.SetSeigManager(&_DepositManager.TransactOpts, seigManager) 1969 } 1970 1971 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 1972 // 1973 // Solidity: function transferOwnership(address newOwner) returns() 1974 func (_DepositManager *DepositManagerTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 1975 return _DepositManager.contract.Transact(opts, "transferOwnership", newOwner) 1976 } 1977 1978 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 1979 // 1980 // Solidity: function transferOwnership(address newOwner) returns() 1981 func (_DepositManager *DepositManagerSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 1982 return _DepositManager.Contract.TransferOwnership(&_DepositManager.TransactOpts, newOwner) 1983 } 1984 1985 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 1986 // 1987 // Solidity: function transferOwnership(address newOwner) returns() 1988 func (_DepositManager *DepositManagerTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 1989 return _DepositManager.Contract.TransferOwnership(&_DepositManager.TransactOpts, newOwner) 1990 } 1991 1992 // DepositManagerDepositedIterator is returned from FilterDeposited and is used to iterate over the raw logs and unpacked data for Deposited events raised by the DepositManager contract. 1993 type DepositManagerDepositedIterator struct { 1994 Event *DepositManagerDeposited // Event containing the contract specifics and raw log 1995 1996 contract *bind.BoundContract // Generic contract to use for unpacking event data 1997 event string // Event name to use for unpacking event data 1998 1999 logs chan types.Log // Log channel receiving the found contract events 2000 sub ethereum.Subscription // Subscription for errors, completion and termination 2001 done bool // Whether the subscription completed delivering logs 2002 fail error // Occurred error to stop iteration 2003 } 2004 2005 // Next advances the iterator to the subsequent event, returning whether there 2006 // are any more events found. In case of a retrieval or parsing error, false is 2007 // returned and Error() can be queried for the exact failure. 2008 func (it *DepositManagerDepositedIterator) Next() bool { 2009 // If the iterator failed, stop iterating 2010 if it.fail != nil { 2011 return false 2012 } 2013 // If the iterator completed, deliver directly whatever's available 2014 if it.done { 2015 select { 2016 case log := <-it.logs: 2017 it.Event = new(DepositManagerDeposited) 2018 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2019 it.fail = err 2020 return false 2021 } 2022 it.Event.Raw = log 2023 return true 2024 2025 default: 2026 return false 2027 } 2028 } 2029 // Iterator still in progress, wait for either a data or an error event 2030 select { 2031 case log := <-it.logs: 2032 it.Event = new(DepositManagerDeposited) 2033 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2034 it.fail = err 2035 return false 2036 } 2037 it.Event.Raw = log 2038 return true 2039 2040 case err := <-it.sub.Err(): 2041 it.done = true 2042 it.fail = err 2043 return it.Next() 2044 } 2045 } 2046 2047 // Error returns any retrieval or parsing error occurred during filtering. 2048 func (it *DepositManagerDepositedIterator) Error() error { 2049 return it.fail 2050 } 2051 2052 // Close terminates the iteration process, releasing any pending underlying 2053 // resources. 2054 func (it *DepositManagerDepositedIterator) Close() error { 2055 it.sub.Unsubscribe() 2056 return nil 2057 } 2058 2059 // DepositManagerDeposited represents a Deposited event raised by the DepositManager contract. 2060 type DepositManagerDeposited struct { 2061 Rootchain common.Address 2062 Depositor common.Address 2063 Amount *big.Int 2064 Raw types.Log // Blockchain specific contextual infos 2065 } 2066 2067 // FilterDeposited is a free log retrieval operation binding the contract event 0x8752a472e571a816aea92eec8dae9baf628e840f4929fbcc2d155e6233ff68a7. 2068 // 2069 // Solidity: event Deposited(address indexed rootchain, address depositor, uint256 amount) 2070 func (_DepositManager *DepositManagerFilterer) FilterDeposited(opts *bind.FilterOpts, rootchain []common.Address) (*DepositManagerDepositedIterator, error) { 2071 2072 var rootchainRule []interface{} 2073 for _, rootchainItem := range rootchain { 2074 rootchainRule = append(rootchainRule, rootchainItem) 2075 } 2076 2077 logs, sub, err := _DepositManager.contract.FilterLogs(opts, "Deposited", rootchainRule) 2078 if err != nil { 2079 return nil, err 2080 } 2081 return &DepositManagerDepositedIterator{contract: _DepositManager.contract, event: "Deposited", logs: logs, sub: sub}, nil 2082 } 2083 2084 // WatchDeposited is a free log subscription operation binding the contract event 0x8752a472e571a816aea92eec8dae9baf628e840f4929fbcc2d155e6233ff68a7. 2085 // 2086 // Solidity: event Deposited(address indexed rootchain, address depositor, uint256 amount) 2087 func (_DepositManager *DepositManagerFilterer) WatchDeposited(opts *bind.WatchOpts, sink chan<- *DepositManagerDeposited, rootchain []common.Address) (event.Subscription, error) { 2088 2089 var rootchainRule []interface{} 2090 for _, rootchainItem := range rootchain { 2091 rootchainRule = append(rootchainRule, rootchainItem) 2092 } 2093 2094 logs, sub, err := _DepositManager.contract.WatchLogs(opts, "Deposited", rootchainRule) 2095 if err != nil { 2096 return nil, err 2097 } 2098 return event.NewSubscription(func(quit <-chan struct{}) error { 2099 defer sub.Unsubscribe() 2100 for { 2101 select { 2102 case log := <-logs: 2103 // New log arrived, parse the event and forward to the user 2104 event := new(DepositManagerDeposited) 2105 if err := _DepositManager.contract.UnpackLog(event, "Deposited", log); err != nil { 2106 return err 2107 } 2108 event.Raw = log 2109 2110 select { 2111 case sink <- event: 2112 case err := <-sub.Err(): 2113 return err 2114 case <-quit: 2115 return nil 2116 } 2117 case err := <-sub.Err(): 2118 return err 2119 case <-quit: 2120 return nil 2121 } 2122 } 2123 }), nil 2124 } 2125 2126 // ParseDeposited is a log parse operation binding the contract event 0x8752a472e571a816aea92eec8dae9baf628e840f4929fbcc2d155e6233ff68a7. 2127 // 2128 // Solidity: event Deposited(address indexed rootchain, address depositor, uint256 amount) 2129 func (_DepositManager *DepositManagerFilterer) ParseDeposited(log types.Log) (*DepositManagerDeposited, error) { 2130 event := new(DepositManagerDeposited) 2131 if err := _DepositManager.contract.UnpackLog(event, "Deposited", log); err != nil { 2132 return nil, err 2133 } 2134 return event, nil 2135 } 2136 2137 // DepositManagerOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the DepositManager contract. 2138 type DepositManagerOwnershipTransferredIterator struct { 2139 Event *DepositManagerOwnershipTransferred // Event containing the contract specifics and raw log 2140 2141 contract *bind.BoundContract // Generic contract to use for unpacking event data 2142 event string // Event name to use for unpacking event data 2143 2144 logs chan types.Log // Log channel receiving the found contract events 2145 sub ethereum.Subscription // Subscription for errors, completion and termination 2146 done bool // Whether the subscription completed delivering logs 2147 fail error // Occurred error to stop iteration 2148 } 2149 2150 // Next advances the iterator to the subsequent event, returning whether there 2151 // are any more events found. In case of a retrieval or parsing error, false is 2152 // returned and Error() can be queried for the exact failure. 2153 func (it *DepositManagerOwnershipTransferredIterator) Next() bool { 2154 // If the iterator failed, stop iterating 2155 if it.fail != nil { 2156 return false 2157 } 2158 // If the iterator completed, deliver directly whatever's available 2159 if it.done { 2160 select { 2161 case log := <-it.logs: 2162 it.Event = new(DepositManagerOwnershipTransferred) 2163 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2164 it.fail = err 2165 return false 2166 } 2167 it.Event.Raw = log 2168 return true 2169 2170 default: 2171 return false 2172 } 2173 } 2174 // Iterator still in progress, wait for either a data or an error event 2175 select { 2176 case log := <-it.logs: 2177 it.Event = new(DepositManagerOwnershipTransferred) 2178 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2179 it.fail = err 2180 return false 2181 } 2182 it.Event.Raw = log 2183 return true 2184 2185 case err := <-it.sub.Err(): 2186 it.done = true 2187 it.fail = err 2188 return it.Next() 2189 } 2190 } 2191 2192 // Error returns any retrieval or parsing error occurred during filtering. 2193 func (it *DepositManagerOwnershipTransferredIterator) Error() error { 2194 return it.fail 2195 } 2196 2197 // Close terminates the iteration process, releasing any pending underlying 2198 // resources. 2199 func (it *DepositManagerOwnershipTransferredIterator) Close() error { 2200 it.sub.Unsubscribe() 2201 return nil 2202 } 2203 2204 // DepositManagerOwnershipTransferred represents a OwnershipTransferred event raised by the DepositManager contract. 2205 type DepositManagerOwnershipTransferred struct { 2206 PreviousOwner common.Address 2207 NewOwner common.Address 2208 Raw types.Log // Blockchain specific contextual infos 2209 } 2210 2211 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 2212 // 2213 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 2214 func (_DepositManager *DepositManagerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*DepositManagerOwnershipTransferredIterator, error) { 2215 2216 var previousOwnerRule []interface{} 2217 for _, previousOwnerItem := range previousOwner { 2218 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 2219 } 2220 var newOwnerRule []interface{} 2221 for _, newOwnerItem := range newOwner { 2222 newOwnerRule = append(newOwnerRule, newOwnerItem) 2223 } 2224 2225 logs, sub, err := _DepositManager.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 2226 if err != nil { 2227 return nil, err 2228 } 2229 return &DepositManagerOwnershipTransferredIterator{contract: _DepositManager.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 2230 } 2231 2232 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 2233 // 2234 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 2235 func (_DepositManager *DepositManagerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *DepositManagerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 2236 2237 var previousOwnerRule []interface{} 2238 for _, previousOwnerItem := range previousOwner { 2239 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 2240 } 2241 var newOwnerRule []interface{} 2242 for _, newOwnerItem := range newOwner { 2243 newOwnerRule = append(newOwnerRule, newOwnerItem) 2244 } 2245 2246 logs, sub, err := _DepositManager.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 2247 if err != nil { 2248 return nil, err 2249 } 2250 return event.NewSubscription(func(quit <-chan struct{}) error { 2251 defer sub.Unsubscribe() 2252 for { 2253 select { 2254 case log := <-logs: 2255 // New log arrived, parse the event and forward to the user 2256 event := new(DepositManagerOwnershipTransferred) 2257 if err := _DepositManager.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 2258 return err 2259 } 2260 event.Raw = log 2261 2262 select { 2263 case sink <- event: 2264 case err := <-sub.Err(): 2265 return err 2266 case <-quit: 2267 return nil 2268 } 2269 case err := <-sub.Err(): 2270 return err 2271 case <-quit: 2272 return nil 2273 } 2274 } 2275 }), nil 2276 } 2277 2278 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 2279 // 2280 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 2281 func (_DepositManager *DepositManagerFilterer) ParseOwnershipTransferred(log types.Log) (*DepositManagerOwnershipTransferred, error) { 2282 event := new(DepositManagerOwnershipTransferred) 2283 if err := _DepositManager.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 2284 return nil, err 2285 } 2286 return event, nil 2287 } 2288 2289 // DepositManagerWithdrawalProcessedIterator is returned from FilterWithdrawalProcessed and is used to iterate over the raw logs and unpacked data for WithdrawalProcessed events raised by the DepositManager contract. 2290 type DepositManagerWithdrawalProcessedIterator struct { 2291 Event *DepositManagerWithdrawalProcessed // Event containing the contract specifics and raw log 2292 2293 contract *bind.BoundContract // Generic contract to use for unpacking event data 2294 event string // Event name to use for unpacking event data 2295 2296 logs chan types.Log // Log channel receiving the found contract events 2297 sub ethereum.Subscription // Subscription for errors, completion and termination 2298 done bool // Whether the subscription completed delivering logs 2299 fail error // Occurred error to stop iteration 2300 } 2301 2302 // Next advances the iterator to the subsequent event, returning whether there 2303 // are any more events found. In case of a retrieval or parsing error, false is 2304 // returned and Error() can be queried for the exact failure. 2305 func (it *DepositManagerWithdrawalProcessedIterator) Next() bool { 2306 // If the iterator failed, stop iterating 2307 if it.fail != nil { 2308 return false 2309 } 2310 // If the iterator completed, deliver directly whatever's available 2311 if it.done { 2312 select { 2313 case log := <-it.logs: 2314 it.Event = new(DepositManagerWithdrawalProcessed) 2315 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2316 it.fail = err 2317 return false 2318 } 2319 it.Event.Raw = log 2320 return true 2321 2322 default: 2323 return false 2324 } 2325 } 2326 // Iterator still in progress, wait for either a data or an error event 2327 select { 2328 case log := <-it.logs: 2329 it.Event = new(DepositManagerWithdrawalProcessed) 2330 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2331 it.fail = err 2332 return false 2333 } 2334 it.Event.Raw = log 2335 return true 2336 2337 case err := <-it.sub.Err(): 2338 it.done = true 2339 it.fail = err 2340 return it.Next() 2341 } 2342 } 2343 2344 // Error returns any retrieval or parsing error occurred during filtering. 2345 func (it *DepositManagerWithdrawalProcessedIterator) Error() error { 2346 return it.fail 2347 } 2348 2349 // Close terminates the iteration process, releasing any pending underlying 2350 // resources. 2351 func (it *DepositManagerWithdrawalProcessedIterator) Close() error { 2352 it.sub.Unsubscribe() 2353 return nil 2354 } 2355 2356 // DepositManagerWithdrawalProcessed represents a WithdrawalProcessed event raised by the DepositManager contract. 2357 type DepositManagerWithdrawalProcessed struct { 2358 Rootchain common.Address 2359 Depositor common.Address 2360 Amount *big.Int 2361 Raw types.Log // Blockchain specific contextual infos 2362 } 2363 2364 // FilterWithdrawalProcessed is a free log retrieval operation binding the contract event 0xcd1fce47d5ad89dd70b04c75bd6bdb8114d4d4ff7b4393f9fb5937e733ba9582. 2365 // 2366 // Solidity: event WithdrawalProcessed(address indexed rootchain, address depositor, uint256 amount) 2367 func (_DepositManager *DepositManagerFilterer) FilterWithdrawalProcessed(opts *bind.FilterOpts, rootchain []common.Address) (*DepositManagerWithdrawalProcessedIterator, error) { 2368 2369 var rootchainRule []interface{} 2370 for _, rootchainItem := range rootchain { 2371 rootchainRule = append(rootchainRule, rootchainItem) 2372 } 2373 2374 logs, sub, err := _DepositManager.contract.FilterLogs(opts, "WithdrawalProcessed", rootchainRule) 2375 if err != nil { 2376 return nil, err 2377 } 2378 return &DepositManagerWithdrawalProcessedIterator{contract: _DepositManager.contract, event: "WithdrawalProcessed", logs: logs, sub: sub}, nil 2379 } 2380 2381 // WatchWithdrawalProcessed is a free log subscription operation binding the contract event 0xcd1fce47d5ad89dd70b04c75bd6bdb8114d4d4ff7b4393f9fb5937e733ba9582. 2382 // 2383 // Solidity: event WithdrawalProcessed(address indexed rootchain, address depositor, uint256 amount) 2384 func (_DepositManager *DepositManagerFilterer) WatchWithdrawalProcessed(opts *bind.WatchOpts, sink chan<- *DepositManagerWithdrawalProcessed, rootchain []common.Address) (event.Subscription, error) { 2385 2386 var rootchainRule []interface{} 2387 for _, rootchainItem := range rootchain { 2388 rootchainRule = append(rootchainRule, rootchainItem) 2389 } 2390 2391 logs, sub, err := _DepositManager.contract.WatchLogs(opts, "WithdrawalProcessed", rootchainRule) 2392 if err != nil { 2393 return nil, err 2394 } 2395 return event.NewSubscription(func(quit <-chan struct{}) error { 2396 defer sub.Unsubscribe() 2397 for { 2398 select { 2399 case log := <-logs: 2400 // New log arrived, parse the event and forward to the user 2401 event := new(DepositManagerWithdrawalProcessed) 2402 if err := _DepositManager.contract.UnpackLog(event, "WithdrawalProcessed", log); err != nil { 2403 return err 2404 } 2405 event.Raw = log 2406 2407 select { 2408 case sink <- event: 2409 case err := <-sub.Err(): 2410 return err 2411 case <-quit: 2412 return nil 2413 } 2414 case err := <-sub.Err(): 2415 return err 2416 case <-quit: 2417 return nil 2418 } 2419 } 2420 }), nil 2421 } 2422 2423 // ParseWithdrawalProcessed is a log parse operation binding the contract event 0xcd1fce47d5ad89dd70b04c75bd6bdb8114d4d4ff7b4393f9fb5937e733ba9582. 2424 // 2425 // Solidity: event WithdrawalProcessed(address indexed rootchain, address depositor, uint256 amount) 2426 func (_DepositManager *DepositManagerFilterer) ParseWithdrawalProcessed(log types.Log) (*DepositManagerWithdrawalProcessed, error) { 2427 event := new(DepositManagerWithdrawalProcessed) 2428 if err := _DepositManager.contract.UnpackLog(event, "WithdrawalProcessed", log); err != nil { 2429 return nil, err 2430 } 2431 return event, nil 2432 } 2433 2434 // DepositManagerWithdrawalRequestedIterator is returned from FilterWithdrawalRequested and is used to iterate over the raw logs and unpacked data for WithdrawalRequested events raised by the DepositManager contract. 2435 type DepositManagerWithdrawalRequestedIterator struct { 2436 Event *DepositManagerWithdrawalRequested // Event containing the contract specifics and raw log 2437 2438 contract *bind.BoundContract // Generic contract to use for unpacking event data 2439 event string // Event name to use for unpacking event data 2440 2441 logs chan types.Log // Log channel receiving the found contract events 2442 sub ethereum.Subscription // Subscription for errors, completion and termination 2443 done bool // Whether the subscription completed delivering logs 2444 fail error // Occurred error to stop iteration 2445 } 2446 2447 // Next advances the iterator to the subsequent event, returning whether there 2448 // are any more events found. In case of a retrieval or parsing error, false is 2449 // returned and Error() can be queried for the exact failure. 2450 func (it *DepositManagerWithdrawalRequestedIterator) Next() bool { 2451 // If the iterator failed, stop iterating 2452 if it.fail != nil { 2453 return false 2454 } 2455 // If the iterator completed, deliver directly whatever's available 2456 if it.done { 2457 select { 2458 case log := <-it.logs: 2459 it.Event = new(DepositManagerWithdrawalRequested) 2460 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2461 it.fail = err 2462 return false 2463 } 2464 it.Event.Raw = log 2465 return true 2466 2467 default: 2468 return false 2469 } 2470 } 2471 // Iterator still in progress, wait for either a data or an error event 2472 select { 2473 case log := <-it.logs: 2474 it.Event = new(DepositManagerWithdrawalRequested) 2475 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2476 it.fail = err 2477 return false 2478 } 2479 it.Event.Raw = log 2480 return true 2481 2482 case err := <-it.sub.Err(): 2483 it.done = true 2484 it.fail = err 2485 return it.Next() 2486 } 2487 } 2488 2489 // Error returns any retrieval or parsing error occurred during filtering. 2490 func (it *DepositManagerWithdrawalRequestedIterator) Error() error { 2491 return it.fail 2492 } 2493 2494 // Close terminates the iteration process, releasing any pending underlying 2495 // resources. 2496 func (it *DepositManagerWithdrawalRequestedIterator) Close() error { 2497 it.sub.Unsubscribe() 2498 return nil 2499 } 2500 2501 // DepositManagerWithdrawalRequested represents a WithdrawalRequested event raised by the DepositManager contract. 2502 type DepositManagerWithdrawalRequested struct { 2503 Rootchain common.Address 2504 Depositor common.Address 2505 Amount *big.Int 2506 Raw types.Log // Blockchain specific contextual infos 2507 } 2508 2509 // FilterWithdrawalRequested is a free log retrieval operation binding the contract event 0x04c56a409d50971e45c5a2d96e5d557d2b0f1d66d40f14b141e4c958b0f39b32. 2510 // 2511 // Solidity: event WithdrawalRequested(address indexed rootchain, address depositor, uint256 amount) 2512 func (_DepositManager *DepositManagerFilterer) FilterWithdrawalRequested(opts *bind.FilterOpts, rootchain []common.Address) (*DepositManagerWithdrawalRequestedIterator, error) { 2513 2514 var rootchainRule []interface{} 2515 for _, rootchainItem := range rootchain { 2516 rootchainRule = append(rootchainRule, rootchainItem) 2517 } 2518 2519 logs, sub, err := _DepositManager.contract.FilterLogs(opts, "WithdrawalRequested", rootchainRule) 2520 if err != nil { 2521 return nil, err 2522 } 2523 return &DepositManagerWithdrawalRequestedIterator{contract: _DepositManager.contract, event: "WithdrawalRequested", logs: logs, sub: sub}, nil 2524 } 2525 2526 // WatchWithdrawalRequested is a free log subscription operation binding the contract event 0x04c56a409d50971e45c5a2d96e5d557d2b0f1d66d40f14b141e4c958b0f39b32. 2527 // 2528 // Solidity: event WithdrawalRequested(address indexed rootchain, address depositor, uint256 amount) 2529 func (_DepositManager *DepositManagerFilterer) WatchWithdrawalRequested(opts *bind.WatchOpts, sink chan<- *DepositManagerWithdrawalRequested, rootchain []common.Address) (event.Subscription, error) { 2530 2531 var rootchainRule []interface{} 2532 for _, rootchainItem := range rootchain { 2533 rootchainRule = append(rootchainRule, rootchainItem) 2534 } 2535 2536 logs, sub, err := _DepositManager.contract.WatchLogs(opts, "WithdrawalRequested", rootchainRule) 2537 if err != nil { 2538 return nil, err 2539 } 2540 return event.NewSubscription(func(quit <-chan struct{}) error { 2541 defer sub.Unsubscribe() 2542 for { 2543 select { 2544 case log := <-logs: 2545 // New log arrived, parse the event and forward to the user 2546 event := new(DepositManagerWithdrawalRequested) 2547 if err := _DepositManager.contract.UnpackLog(event, "WithdrawalRequested", log); err != nil { 2548 return err 2549 } 2550 event.Raw = log 2551 2552 select { 2553 case sink <- event: 2554 case err := <-sub.Err(): 2555 return err 2556 case <-quit: 2557 return nil 2558 } 2559 case err := <-sub.Err(): 2560 return err 2561 case <-quit: 2562 return nil 2563 } 2564 } 2565 }), nil 2566 } 2567 2568 // ParseWithdrawalRequested is a log parse operation binding the contract event 0x04c56a409d50971e45c5a2d96e5d557d2b0f1d66d40f14b141e4c958b0f39b32. 2569 // 2570 // Solidity: event WithdrawalRequested(address indexed rootchain, address depositor, uint256 amount) 2571 func (_DepositManager *DepositManagerFilterer) ParseWithdrawalRequested(log types.Log) (*DepositManagerWithdrawalRequested, error) { 2572 event := new(DepositManagerWithdrawalRequested) 2573 if err := _DepositManager.contract.UnpackLog(event, "WithdrawalRequested", log); err != nil { 2574 return nil, err 2575 } 2576 return event, nil 2577 } 2578 2579 // DepositManagerIABI is the input ABI used to generate the binding from. 2580 const DepositManagerIABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"WITHDRAWAL_DELAY\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accStaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accStakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"accStakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accUnstaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"accUnstakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"accUnstakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"deposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"numPendingRequests\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"numRequests\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"owner\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"pendingUnstaked\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"pendingUnstakedAccount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"pendingUnstakedRootChain\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"processRequest\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"n\",\"type\":\"uint256\"}],\"name\":\"processRequests\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"requestWithdrawal\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"requestWithdrawalAll\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"seigManager\",\"type\":\"address\"}],\"name\":\"setSeigManager\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"withdrawalRequest\",\"outputs\":[{\"internalType\":\"uint128\",\"name\":\"withdrawableBlockNumber\",\"type\":\"uint128\"},{\"internalType\":\"uint128\",\"name\":\"amount\",\"type\":\"uint128\"},{\"internalType\":\"bool\",\"name\":\"processed\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"withdrawalRequestIndex\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"wton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]" 2581 2582 // DepositManagerIFuncSigs maps the 4-byte function signature to its string representation. 2583 var DepositManagerIFuncSigs = map[string]string{ 2584 "0ebb172a": "WITHDRAWAL_DELAY()", 2585 "2d2fab94": "accStaked(address,address)", 2586 "0055f5c1": "accStakedAccount(address)", 2587 "e8035ec9": "accStakedRootChain(address)", 2588 "9d91b87b": "accUnstaked(address,address)", 2589 "a3543989": "accUnstakedAccount(address)", 2590 "03dc6510": "accUnstakedRootChain(address)", 2591 "47e7ef24": "deposit(address,uint256)", 2592 "5c0df46b": "numPendingRequests(address,address)", 2593 "f762eb57": "numRequests(address,address)", 2594 "8da5cb5b": "owner()", 2595 "2638fdf5": "pendingUnstaked(address,address)", 2596 "a0b2a913": "pendingUnstakedAccount(address)", 2597 "a8f3fb98": "pendingUnstakedRootChain(address)", 2598 "5d6f7cca": "processRequest(address)", 2599 "06260ceb": "processRequests(address,uint256)", 2600 "7b103999": "registry()", 2601 "da95ebf7": "requestWithdrawal(address,uint256)", 2602 "6b2160b7": "requestWithdrawalAll(address)", 2603 "6fb7f558": "seigManager()", 2604 "7657f20a": "setSeigManager(address)", 2605 "8fbef2d0": "withdrawalRequest(address,address,uint256)", 2606 "c647f26e": "withdrawalRequestIndex(address,address)", 2607 "8d62d949": "wton()", 2608 } 2609 2610 // DepositManagerI is an auto generated Go binding around an Ethereum contract. 2611 type DepositManagerI struct { 2612 DepositManagerICaller // Read-only binding to the contract 2613 DepositManagerITransactor // Write-only binding to the contract 2614 DepositManagerIFilterer // Log filterer for contract events 2615 } 2616 2617 // DepositManagerICaller is an auto generated read-only Go binding around an Ethereum contract. 2618 type DepositManagerICaller struct { 2619 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2620 } 2621 2622 // DepositManagerITransactor is an auto generated write-only Go binding around an Ethereum contract. 2623 type DepositManagerITransactor struct { 2624 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2625 } 2626 2627 // DepositManagerIFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 2628 type DepositManagerIFilterer struct { 2629 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2630 } 2631 2632 // DepositManagerISession is an auto generated Go binding around an Ethereum contract, 2633 // with pre-set call and transact options. 2634 type DepositManagerISession struct { 2635 Contract *DepositManagerI // Generic contract binding to set the session for 2636 CallOpts bind.CallOpts // Call options to use throughout this session 2637 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 2638 } 2639 2640 // DepositManagerICallerSession is an auto generated read-only Go binding around an Ethereum contract, 2641 // with pre-set call options. 2642 type DepositManagerICallerSession struct { 2643 Contract *DepositManagerICaller // Generic contract caller binding to set the session for 2644 CallOpts bind.CallOpts // Call options to use throughout this session 2645 } 2646 2647 // DepositManagerITransactorSession is an auto generated write-only Go binding around an Ethereum contract, 2648 // with pre-set transact options. 2649 type DepositManagerITransactorSession struct { 2650 Contract *DepositManagerITransactor // Generic contract transactor binding to set the session for 2651 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 2652 } 2653 2654 // DepositManagerIRaw is an auto generated low-level Go binding around an Ethereum contract. 2655 type DepositManagerIRaw struct { 2656 Contract *DepositManagerI // Generic contract binding to access the raw methods on 2657 } 2658 2659 // DepositManagerICallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 2660 type DepositManagerICallerRaw struct { 2661 Contract *DepositManagerICaller // Generic read-only contract binding to access the raw methods on 2662 } 2663 2664 // DepositManagerITransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 2665 type DepositManagerITransactorRaw struct { 2666 Contract *DepositManagerITransactor // Generic write-only contract binding to access the raw methods on 2667 } 2668 2669 // NewDepositManagerI creates a new instance of DepositManagerI, bound to a specific deployed contract. 2670 func NewDepositManagerI(address common.Address, backend bind.ContractBackend) (*DepositManagerI, error) { 2671 contract, err := bindDepositManagerI(address, backend, backend, backend) 2672 if err != nil { 2673 return nil, err 2674 } 2675 return &DepositManagerI{DepositManagerICaller: DepositManagerICaller{contract: contract}, DepositManagerITransactor: DepositManagerITransactor{contract: contract}, DepositManagerIFilterer: DepositManagerIFilterer{contract: contract}}, nil 2676 } 2677 2678 // NewDepositManagerICaller creates a new read-only instance of DepositManagerI, bound to a specific deployed contract. 2679 func NewDepositManagerICaller(address common.Address, caller bind.ContractCaller) (*DepositManagerICaller, error) { 2680 contract, err := bindDepositManagerI(address, caller, nil, nil) 2681 if err != nil { 2682 return nil, err 2683 } 2684 return &DepositManagerICaller{contract: contract}, nil 2685 } 2686 2687 // NewDepositManagerITransactor creates a new write-only instance of DepositManagerI, bound to a specific deployed contract. 2688 func NewDepositManagerITransactor(address common.Address, transactor bind.ContractTransactor) (*DepositManagerITransactor, error) { 2689 contract, err := bindDepositManagerI(address, nil, transactor, nil) 2690 if err != nil { 2691 return nil, err 2692 } 2693 return &DepositManagerITransactor{contract: contract}, nil 2694 } 2695 2696 // NewDepositManagerIFilterer creates a new log filterer instance of DepositManagerI, bound to a specific deployed contract. 2697 func NewDepositManagerIFilterer(address common.Address, filterer bind.ContractFilterer) (*DepositManagerIFilterer, error) { 2698 contract, err := bindDepositManagerI(address, nil, nil, filterer) 2699 if err != nil { 2700 return nil, err 2701 } 2702 return &DepositManagerIFilterer{contract: contract}, nil 2703 } 2704 2705 // bindDepositManagerI binds a generic wrapper to an already deployed contract. 2706 func bindDepositManagerI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 2707 parsed, err := abi.JSON(strings.NewReader(DepositManagerIABI)) 2708 if err != nil { 2709 return nil, err 2710 } 2711 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 2712 } 2713 2714 // Call invokes the (constant) contract method with params as input values and 2715 // sets the output to result. The result type might be a single field for simple 2716 // returns, a slice of interfaces for anonymous returns and a struct for named 2717 // returns. 2718 func (_DepositManagerI *DepositManagerIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 2719 return _DepositManagerI.Contract.DepositManagerICaller.contract.Call(opts, result, method, params...) 2720 } 2721 2722 // Transfer initiates a plain transaction to move funds to the contract, calling 2723 // its default method if one is available. 2724 func (_DepositManagerI *DepositManagerIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 2725 return _DepositManagerI.Contract.DepositManagerITransactor.contract.Transfer(opts) 2726 } 2727 2728 // Transact invokes the (paid) contract method with params as input values. 2729 func (_DepositManagerI *DepositManagerIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 2730 return _DepositManagerI.Contract.DepositManagerITransactor.contract.Transact(opts, method, params...) 2731 } 2732 2733 // Call invokes the (constant) contract method with params as input values and 2734 // sets the output to result. The result type might be a single field for simple 2735 // returns, a slice of interfaces for anonymous returns and a struct for named 2736 // returns. 2737 func (_DepositManagerI *DepositManagerICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 2738 return _DepositManagerI.Contract.contract.Call(opts, result, method, params...) 2739 } 2740 2741 // Transfer initiates a plain transaction to move funds to the contract, calling 2742 // its default method if one is available. 2743 func (_DepositManagerI *DepositManagerITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 2744 return _DepositManagerI.Contract.contract.Transfer(opts) 2745 } 2746 2747 // Transact invokes the (paid) contract method with params as input values. 2748 func (_DepositManagerI *DepositManagerITransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 2749 return _DepositManagerI.Contract.contract.Transact(opts, method, params...) 2750 } 2751 2752 // WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a. 2753 // 2754 // Solidity: function WITHDRAWAL_DELAY() constant returns(uint256) 2755 func (_DepositManagerI *DepositManagerICaller) WITHDRAWALDELAY(opts *bind.CallOpts) (*big.Int, error) { 2756 var ( 2757 ret0 = new(*big.Int) 2758 ) 2759 out := ret0 2760 err := _DepositManagerI.contract.Call(opts, out, "WITHDRAWAL_DELAY") 2761 return *ret0, err 2762 } 2763 2764 // WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a. 2765 // 2766 // Solidity: function WITHDRAWAL_DELAY() constant returns(uint256) 2767 func (_DepositManagerI *DepositManagerISession) WITHDRAWALDELAY() (*big.Int, error) { 2768 return _DepositManagerI.Contract.WITHDRAWALDELAY(&_DepositManagerI.CallOpts) 2769 } 2770 2771 // WITHDRAWALDELAY is a free data retrieval call binding the contract method 0x0ebb172a. 2772 // 2773 // Solidity: function WITHDRAWAL_DELAY() constant returns(uint256) 2774 func (_DepositManagerI *DepositManagerICallerSession) WITHDRAWALDELAY() (*big.Int, error) { 2775 return _DepositManagerI.Contract.WITHDRAWALDELAY(&_DepositManagerI.CallOpts) 2776 } 2777 2778 // AccStaked is a free data retrieval call binding the contract method 0x2d2fab94. 2779 // 2780 // Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount) 2781 func (_DepositManagerI *DepositManagerICaller) AccStaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 2782 var ( 2783 ret0 = new(*big.Int) 2784 ) 2785 out := ret0 2786 err := _DepositManagerI.contract.Call(opts, out, "accStaked", rootchain, account) 2787 return *ret0, err 2788 } 2789 2790 // AccStaked is a free data retrieval call binding the contract method 0x2d2fab94. 2791 // 2792 // Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount) 2793 func (_DepositManagerI *DepositManagerISession) AccStaked(rootchain common.Address, account common.Address) (*big.Int, error) { 2794 return _DepositManagerI.Contract.AccStaked(&_DepositManagerI.CallOpts, rootchain, account) 2795 } 2796 2797 // AccStaked is a free data retrieval call binding the contract method 0x2d2fab94. 2798 // 2799 // Solidity: function accStaked(address rootchain, address account) constant returns(uint256 wtonAmount) 2800 func (_DepositManagerI *DepositManagerICallerSession) AccStaked(rootchain common.Address, account common.Address) (*big.Int, error) { 2801 return _DepositManagerI.Contract.AccStaked(&_DepositManagerI.CallOpts, rootchain, account) 2802 } 2803 2804 // AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1. 2805 // 2806 // Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount) 2807 func (_DepositManagerI *DepositManagerICaller) AccStakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 2808 var ( 2809 ret0 = new(*big.Int) 2810 ) 2811 out := ret0 2812 err := _DepositManagerI.contract.Call(opts, out, "accStakedAccount", account) 2813 return *ret0, err 2814 } 2815 2816 // AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1. 2817 // 2818 // Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount) 2819 func (_DepositManagerI *DepositManagerISession) AccStakedAccount(account common.Address) (*big.Int, error) { 2820 return _DepositManagerI.Contract.AccStakedAccount(&_DepositManagerI.CallOpts, account) 2821 } 2822 2823 // AccStakedAccount is a free data retrieval call binding the contract method 0x0055f5c1. 2824 // 2825 // Solidity: function accStakedAccount(address account) constant returns(uint256 wtonAmount) 2826 func (_DepositManagerI *DepositManagerICallerSession) AccStakedAccount(account common.Address) (*big.Int, error) { 2827 return _DepositManagerI.Contract.AccStakedAccount(&_DepositManagerI.CallOpts, account) 2828 } 2829 2830 // AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9. 2831 // 2832 // Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 2833 func (_DepositManagerI *DepositManagerICaller) AccStakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) { 2834 var ( 2835 ret0 = new(*big.Int) 2836 ) 2837 out := ret0 2838 err := _DepositManagerI.contract.Call(opts, out, "accStakedRootChain", rootchain) 2839 return *ret0, err 2840 } 2841 2842 // AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9. 2843 // 2844 // Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 2845 func (_DepositManagerI *DepositManagerISession) AccStakedRootChain(rootchain common.Address) (*big.Int, error) { 2846 return _DepositManagerI.Contract.AccStakedRootChain(&_DepositManagerI.CallOpts, rootchain) 2847 } 2848 2849 // AccStakedRootChain is a free data retrieval call binding the contract method 0xe8035ec9. 2850 // 2851 // Solidity: function accStakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 2852 func (_DepositManagerI *DepositManagerICallerSession) AccStakedRootChain(rootchain common.Address) (*big.Int, error) { 2853 return _DepositManagerI.Contract.AccStakedRootChain(&_DepositManagerI.CallOpts, rootchain) 2854 } 2855 2856 // AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b. 2857 // 2858 // Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount) 2859 func (_DepositManagerI *DepositManagerICaller) AccUnstaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 2860 var ( 2861 ret0 = new(*big.Int) 2862 ) 2863 out := ret0 2864 err := _DepositManagerI.contract.Call(opts, out, "accUnstaked", rootchain, account) 2865 return *ret0, err 2866 } 2867 2868 // AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b. 2869 // 2870 // Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount) 2871 func (_DepositManagerI *DepositManagerISession) AccUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) { 2872 return _DepositManagerI.Contract.AccUnstaked(&_DepositManagerI.CallOpts, rootchain, account) 2873 } 2874 2875 // AccUnstaked is a free data retrieval call binding the contract method 0x9d91b87b. 2876 // 2877 // Solidity: function accUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount) 2878 func (_DepositManagerI *DepositManagerICallerSession) AccUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) { 2879 return _DepositManagerI.Contract.AccUnstaked(&_DepositManagerI.CallOpts, rootchain, account) 2880 } 2881 2882 // AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989. 2883 // 2884 // Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount) 2885 func (_DepositManagerI *DepositManagerICaller) AccUnstakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 2886 var ( 2887 ret0 = new(*big.Int) 2888 ) 2889 out := ret0 2890 err := _DepositManagerI.contract.Call(opts, out, "accUnstakedAccount", account) 2891 return *ret0, err 2892 } 2893 2894 // AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989. 2895 // 2896 // Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount) 2897 func (_DepositManagerI *DepositManagerISession) AccUnstakedAccount(account common.Address) (*big.Int, error) { 2898 return _DepositManagerI.Contract.AccUnstakedAccount(&_DepositManagerI.CallOpts, account) 2899 } 2900 2901 // AccUnstakedAccount is a free data retrieval call binding the contract method 0xa3543989. 2902 // 2903 // Solidity: function accUnstakedAccount(address account) constant returns(uint256 wtonAmount) 2904 func (_DepositManagerI *DepositManagerICallerSession) AccUnstakedAccount(account common.Address) (*big.Int, error) { 2905 return _DepositManagerI.Contract.AccUnstakedAccount(&_DepositManagerI.CallOpts, account) 2906 } 2907 2908 // AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510. 2909 // 2910 // Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 2911 func (_DepositManagerI *DepositManagerICaller) AccUnstakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) { 2912 var ( 2913 ret0 = new(*big.Int) 2914 ) 2915 out := ret0 2916 err := _DepositManagerI.contract.Call(opts, out, "accUnstakedRootChain", rootchain) 2917 return *ret0, err 2918 } 2919 2920 // AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510. 2921 // 2922 // Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 2923 func (_DepositManagerI *DepositManagerISession) AccUnstakedRootChain(rootchain common.Address) (*big.Int, error) { 2924 return _DepositManagerI.Contract.AccUnstakedRootChain(&_DepositManagerI.CallOpts, rootchain) 2925 } 2926 2927 // AccUnstakedRootChain is a free data retrieval call binding the contract method 0x03dc6510. 2928 // 2929 // Solidity: function accUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 2930 func (_DepositManagerI *DepositManagerICallerSession) AccUnstakedRootChain(rootchain common.Address) (*big.Int, error) { 2931 return _DepositManagerI.Contract.AccUnstakedRootChain(&_DepositManagerI.CallOpts, rootchain) 2932 } 2933 2934 // NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b. 2935 // 2936 // Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256) 2937 func (_DepositManagerI *DepositManagerICaller) NumPendingRequests(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 2938 var ( 2939 ret0 = new(*big.Int) 2940 ) 2941 out := ret0 2942 err := _DepositManagerI.contract.Call(opts, out, "numPendingRequests", rootchain, account) 2943 return *ret0, err 2944 } 2945 2946 // NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b. 2947 // 2948 // Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256) 2949 func (_DepositManagerI *DepositManagerISession) NumPendingRequests(rootchain common.Address, account common.Address) (*big.Int, error) { 2950 return _DepositManagerI.Contract.NumPendingRequests(&_DepositManagerI.CallOpts, rootchain, account) 2951 } 2952 2953 // NumPendingRequests is a free data retrieval call binding the contract method 0x5c0df46b. 2954 // 2955 // Solidity: function numPendingRequests(address rootchain, address account) constant returns(uint256) 2956 func (_DepositManagerI *DepositManagerICallerSession) NumPendingRequests(rootchain common.Address, account common.Address) (*big.Int, error) { 2957 return _DepositManagerI.Contract.NumPendingRequests(&_DepositManagerI.CallOpts, rootchain, account) 2958 } 2959 2960 // NumRequests is a free data retrieval call binding the contract method 0xf762eb57. 2961 // 2962 // Solidity: function numRequests(address rootchain, address account) constant returns(uint256) 2963 func (_DepositManagerI *DepositManagerICaller) NumRequests(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 2964 var ( 2965 ret0 = new(*big.Int) 2966 ) 2967 out := ret0 2968 err := _DepositManagerI.contract.Call(opts, out, "numRequests", rootchain, account) 2969 return *ret0, err 2970 } 2971 2972 // NumRequests is a free data retrieval call binding the contract method 0xf762eb57. 2973 // 2974 // Solidity: function numRequests(address rootchain, address account) constant returns(uint256) 2975 func (_DepositManagerI *DepositManagerISession) NumRequests(rootchain common.Address, account common.Address) (*big.Int, error) { 2976 return _DepositManagerI.Contract.NumRequests(&_DepositManagerI.CallOpts, rootchain, account) 2977 } 2978 2979 // NumRequests is a free data retrieval call binding the contract method 0xf762eb57. 2980 // 2981 // Solidity: function numRequests(address rootchain, address account) constant returns(uint256) 2982 func (_DepositManagerI *DepositManagerICallerSession) NumRequests(rootchain common.Address, account common.Address) (*big.Int, error) { 2983 return _DepositManagerI.Contract.NumRequests(&_DepositManagerI.CallOpts, rootchain, account) 2984 } 2985 2986 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 2987 // 2988 // Solidity: function owner() constant returns(address) 2989 func (_DepositManagerI *DepositManagerICaller) Owner(opts *bind.CallOpts) (common.Address, error) { 2990 var ( 2991 ret0 = new(common.Address) 2992 ) 2993 out := ret0 2994 err := _DepositManagerI.contract.Call(opts, out, "owner") 2995 return *ret0, err 2996 } 2997 2998 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 2999 // 3000 // Solidity: function owner() constant returns(address) 3001 func (_DepositManagerI *DepositManagerISession) Owner() (common.Address, error) { 3002 return _DepositManagerI.Contract.Owner(&_DepositManagerI.CallOpts) 3003 } 3004 3005 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 3006 // 3007 // Solidity: function owner() constant returns(address) 3008 func (_DepositManagerI *DepositManagerICallerSession) Owner() (common.Address, error) { 3009 return _DepositManagerI.Contract.Owner(&_DepositManagerI.CallOpts) 3010 } 3011 3012 // PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5. 3013 // 3014 // Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount) 3015 func (_DepositManagerI *DepositManagerICaller) PendingUnstaked(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 3016 var ( 3017 ret0 = new(*big.Int) 3018 ) 3019 out := ret0 3020 err := _DepositManagerI.contract.Call(opts, out, "pendingUnstaked", rootchain, account) 3021 return *ret0, err 3022 } 3023 3024 // PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5. 3025 // 3026 // Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount) 3027 func (_DepositManagerI *DepositManagerISession) PendingUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) { 3028 return _DepositManagerI.Contract.PendingUnstaked(&_DepositManagerI.CallOpts, rootchain, account) 3029 } 3030 3031 // PendingUnstaked is a free data retrieval call binding the contract method 0x2638fdf5. 3032 // 3033 // Solidity: function pendingUnstaked(address rootchain, address account) constant returns(uint256 wtonAmount) 3034 func (_DepositManagerI *DepositManagerICallerSession) PendingUnstaked(rootchain common.Address, account common.Address) (*big.Int, error) { 3035 return _DepositManagerI.Contract.PendingUnstaked(&_DepositManagerI.CallOpts, rootchain, account) 3036 } 3037 3038 // PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913. 3039 // 3040 // Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount) 3041 func (_DepositManagerI *DepositManagerICaller) PendingUnstakedAccount(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 3042 var ( 3043 ret0 = new(*big.Int) 3044 ) 3045 out := ret0 3046 err := _DepositManagerI.contract.Call(opts, out, "pendingUnstakedAccount", account) 3047 return *ret0, err 3048 } 3049 3050 // PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913. 3051 // 3052 // Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount) 3053 func (_DepositManagerI *DepositManagerISession) PendingUnstakedAccount(account common.Address) (*big.Int, error) { 3054 return _DepositManagerI.Contract.PendingUnstakedAccount(&_DepositManagerI.CallOpts, account) 3055 } 3056 3057 // PendingUnstakedAccount is a free data retrieval call binding the contract method 0xa0b2a913. 3058 // 3059 // Solidity: function pendingUnstakedAccount(address account) constant returns(uint256 wtonAmount) 3060 func (_DepositManagerI *DepositManagerICallerSession) PendingUnstakedAccount(account common.Address) (*big.Int, error) { 3061 return _DepositManagerI.Contract.PendingUnstakedAccount(&_DepositManagerI.CallOpts, account) 3062 } 3063 3064 // PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98. 3065 // 3066 // Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 3067 func (_DepositManagerI *DepositManagerICaller) PendingUnstakedRootChain(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) { 3068 var ( 3069 ret0 = new(*big.Int) 3070 ) 3071 out := ret0 3072 err := _DepositManagerI.contract.Call(opts, out, "pendingUnstakedRootChain", rootchain) 3073 return *ret0, err 3074 } 3075 3076 // PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98. 3077 // 3078 // Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 3079 func (_DepositManagerI *DepositManagerISession) PendingUnstakedRootChain(rootchain common.Address) (*big.Int, error) { 3080 return _DepositManagerI.Contract.PendingUnstakedRootChain(&_DepositManagerI.CallOpts, rootchain) 3081 } 3082 3083 // PendingUnstakedRootChain is a free data retrieval call binding the contract method 0xa8f3fb98. 3084 // 3085 // Solidity: function pendingUnstakedRootChain(address rootchain) constant returns(uint256 wtonAmount) 3086 func (_DepositManagerI *DepositManagerICallerSession) PendingUnstakedRootChain(rootchain common.Address) (*big.Int, error) { 3087 return _DepositManagerI.Contract.PendingUnstakedRootChain(&_DepositManagerI.CallOpts, rootchain) 3088 } 3089 3090 // Registry is a free data retrieval call binding the contract method 0x7b103999. 3091 // 3092 // Solidity: function registry() constant returns(address) 3093 func (_DepositManagerI *DepositManagerICaller) Registry(opts *bind.CallOpts) (common.Address, error) { 3094 var ( 3095 ret0 = new(common.Address) 3096 ) 3097 out := ret0 3098 err := _DepositManagerI.contract.Call(opts, out, "registry") 3099 return *ret0, err 3100 } 3101 3102 // Registry is a free data retrieval call binding the contract method 0x7b103999. 3103 // 3104 // Solidity: function registry() constant returns(address) 3105 func (_DepositManagerI *DepositManagerISession) Registry() (common.Address, error) { 3106 return _DepositManagerI.Contract.Registry(&_DepositManagerI.CallOpts) 3107 } 3108 3109 // Registry is a free data retrieval call binding the contract method 0x7b103999. 3110 // 3111 // Solidity: function registry() constant returns(address) 3112 func (_DepositManagerI *DepositManagerICallerSession) Registry() (common.Address, error) { 3113 return _DepositManagerI.Contract.Registry(&_DepositManagerI.CallOpts) 3114 } 3115 3116 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 3117 // 3118 // Solidity: function seigManager() constant returns(address) 3119 func (_DepositManagerI *DepositManagerICaller) SeigManager(opts *bind.CallOpts) (common.Address, error) { 3120 var ( 3121 ret0 = new(common.Address) 3122 ) 3123 out := ret0 3124 err := _DepositManagerI.contract.Call(opts, out, "seigManager") 3125 return *ret0, err 3126 } 3127 3128 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 3129 // 3130 // Solidity: function seigManager() constant returns(address) 3131 func (_DepositManagerI *DepositManagerISession) SeigManager() (common.Address, error) { 3132 return _DepositManagerI.Contract.SeigManager(&_DepositManagerI.CallOpts) 3133 } 3134 3135 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 3136 // 3137 // Solidity: function seigManager() constant returns(address) 3138 func (_DepositManagerI *DepositManagerICallerSession) SeigManager() (common.Address, error) { 3139 return _DepositManagerI.Contract.SeigManager(&_DepositManagerI.CallOpts) 3140 } 3141 3142 // WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0. 3143 // 3144 // Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed) 3145 func (_DepositManagerI *DepositManagerICaller) WithdrawalRequest(opts *bind.CallOpts, rootchain common.Address, account common.Address, index *big.Int) (struct { 3146 WithdrawableBlockNumber *big.Int 3147 Amount *big.Int 3148 Processed bool 3149 }, error) { 3150 ret := new(struct { 3151 WithdrawableBlockNumber *big.Int 3152 Amount *big.Int 3153 Processed bool 3154 }) 3155 out := ret 3156 err := _DepositManagerI.contract.Call(opts, out, "withdrawalRequest", rootchain, account, index) 3157 return *ret, err 3158 } 3159 3160 // WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0. 3161 // 3162 // Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed) 3163 func (_DepositManagerI *DepositManagerISession) WithdrawalRequest(rootchain common.Address, account common.Address, index *big.Int) (struct { 3164 WithdrawableBlockNumber *big.Int 3165 Amount *big.Int 3166 Processed bool 3167 }, error) { 3168 return _DepositManagerI.Contract.WithdrawalRequest(&_DepositManagerI.CallOpts, rootchain, account, index) 3169 } 3170 3171 // WithdrawalRequest is a free data retrieval call binding the contract method 0x8fbef2d0. 3172 // 3173 // Solidity: function withdrawalRequest(address rootchain, address account, uint256 index) constant returns(uint128 withdrawableBlockNumber, uint128 amount, bool processed) 3174 func (_DepositManagerI *DepositManagerICallerSession) WithdrawalRequest(rootchain common.Address, account common.Address, index *big.Int) (struct { 3175 WithdrawableBlockNumber *big.Int 3176 Amount *big.Int 3177 Processed bool 3178 }, error) { 3179 return _DepositManagerI.Contract.WithdrawalRequest(&_DepositManagerI.CallOpts, rootchain, account, index) 3180 } 3181 3182 // WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e. 3183 // 3184 // Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index) 3185 func (_DepositManagerI *DepositManagerICaller) WithdrawalRequestIndex(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 3186 var ( 3187 ret0 = new(*big.Int) 3188 ) 3189 out := ret0 3190 err := _DepositManagerI.contract.Call(opts, out, "withdrawalRequestIndex", rootchain, account) 3191 return *ret0, err 3192 } 3193 3194 // WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e. 3195 // 3196 // Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index) 3197 func (_DepositManagerI *DepositManagerISession) WithdrawalRequestIndex(rootchain common.Address, account common.Address) (*big.Int, error) { 3198 return _DepositManagerI.Contract.WithdrawalRequestIndex(&_DepositManagerI.CallOpts, rootchain, account) 3199 } 3200 3201 // WithdrawalRequestIndex is a free data retrieval call binding the contract method 0xc647f26e. 3202 // 3203 // Solidity: function withdrawalRequestIndex(address rootchain, address account) constant returns(uint256 index) 3204 func (_DepositManagerI *DepositManagerICallerSession) WithdrawalRequestIndex(rootchain common.Address, account common.Address) (*big.Int, error) { 3205 return _DepositManagerI.Contract.WithdrawalRequestIndex(&_DepositManagerI.CallOpts, rootchain, account) 3206 } 3207 3208 // Wton is a free data retrieval call binding the contract method 0x8d62d949. 3209 // 3210 // Solidity: function wton() constant returns(address) 3211 func (_DepositManagerI *DepositManagerICaller) Wton(opts *bind.CallOpts) (common.Address, error) { 3212 var ( 3213 ret0 = new(common.Address) 3214 ) 3215 out := ret0 3216 err := _DepositManagerI.contract.Call(opts, out, "wton") 3217 return *ret0, err 3218 } 3219 3220 // Wton is a free data retrieval call binding the contract method 0x8d62d949. 3221 // 3222 // Solidity: function wton() constant returns(address) 3223 func (_DepositManagerI *DepositManagerISession) Wton() (common.Address, error) { 3224 return _DepositManagerI.Contract.Wton(&_DepositManagerI.CallOpts) 3225 } 3226 3227 // Wton is a free data retrieval call binding the contract method 0x8d62d949. 3228 // 3229 // Solidity: function wton() constant returns(address) 3230 func (_DepositManagerI *DepositManagerICallerSession) Wton() (common.Address, error) { 3231 return _DepositManagerI.Contract.Wton(&_DepositManagerI.CallOpts) 3232 } 3233 3234 // Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. 3235 // 3236 // Solidity: function deposit(address rootchain, uint256 amount) returns(bool) 3237 func (_DepositManagerI *DepositManagerITransactor) Deposit(opts *bind.TransactOpts, rootchain common.Address, amount *big.Int) (*types.Transaction, error) { 3238 return _DepositManagerI.contract.Transact(opts, "deposit", rootchain, amount) 3239 } 3240 3241 // Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. 3242 // 3243 // Solidity: function deposit(address rootchain, uint256 amount) returns(bool) 3244 func (_DepositManagerI *DepositManagerISession) Deposit(rootchain common.Address, amount *big.Int) (*types.Transaction, error) { 3245 return _DepositManagerI.Contract.Deposit(&_DepositManagerI.TransactOpts, rootchain, amount) 3246 } 3247 3248 // Deposit is a paid mutator transaction binding the contract method 0x47e7ef24. 3249 // 3250 // Solidity: function deposit(address rootchain, uint256 amount) returns(bool) 3251 func (_DepositManagerI *DepositManagerITransactorSession) Deposit(rootchain common.Address, amount *big.Int) (*types.Transaction, error) { 3252 return _DepositManagerI.Contract.Deposit(&_DepositManagerI.TransactOpts, rootchain, amount) 3253 } 3254 3255 // ProcessRequest is a paid mutator transaction binding the contract method 0x5d6f7cca. 3256 // 3257 // Solidity: function processRequest(address rootchain) returns(bool) 3258 func (_DepositManagerI *DepositManagerITransactor) ProcessRequest(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) { 3259 return _DepositManagerI.contract.Transact(opts, "processRequest", rootchain) 3260 } 3261 3262 // ProcessRequest is a paid mutator transaction binding the contract method 0x5d6f7cca. 3263 // 3264 // Solidity: function processRequest(address rootchain) returns(bool) 3265 func (_DepositManagerI *DepositManagerISession) ProcessRequest(rootchain common.Address) (*types.Transaction, error) { 3266 return _DepositManagerI.Contract.ProcessRequest(&_DepositManagerI.TransactOpts, rootchain) 3267 } 3268 3269 // ProcessRequest is a paid mutator transaction binding the contract method 0x5d6f7cca. 3270 // 3271 // Solidity: function processRequest(address rootchain) returns(bool) 3272 func (_DepositManagerI *DepositManagerITransactorSession) ProcessRequest(rootchain common.Address) (*types.Transaction, error) { 3273 return _DepositManagerI.Contract.ProcessRequest(&_DepositManagerI.TransactOpts, rootchain) 3274 } 3275 3276 // ProcessRequests is a paid mutator transaction binding the contract method 0x06260ceb. 3277 // 3278 // Solidity: function processRequests(address rootchain, uint256 n) returns(bool) 3279 func (_DepositManagerI *DepositManagerITransactor) ProcessRequests(opts *bind.TransactOpts, rootchain common.Address, n *big.Int) (*types.Transaction, error) { 3280 return _DepositManagerI.contract.Transact(opts, "processRequests", rootchain, n) 3281 } 3282 3283 // ProcessRequests is a paid mutator transaction binding the contract method 0x06260ceb. 3284 // 3285 // Solidity: function processRequests(address rootchain, uint256 n) returns(bool) 3286 func (_DepositManagerI *DepositManagerISession) ProcessRequests(rootchain common.Address, n *big.Int) (*types.Transaction, error) { 3287 return _DepositManagerI.Contract.ProcessRequests(&_DepositManagerI.TransactOpts, rootchain, n) 3288 } 3289 3290 // ProcessRequests is a paid mutator transaction binding the contract method 0x06260ceb. 3291 // 3292 // Solidity: function processRequests(address rootchain, uint256 n) returns(bool) 3293 func (_DepositManagerI *DepositManagerITransactorSession) ProcessRequests(rootchain common.Address, n *big.Int) (*types.Transaction, error) { 3294 return _DepositManagerI.Contract.ProcessRequests(&_DepositManagerI.TransactOpts, rootchain, n) 3295 } 3296 3297 // RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7. 3298 // 3299 // Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool) 3300 func (_DepositManagerI *DepositManagerITransactor) RequestWithdrawal(opts *bind.TransactOpts, rootchain common.Address, amount *big.Int) (*types.Transaction, error) { 3301 return _DepositManagerI.contract.Transact(opts, "requestWithdrawal", rootchain, amount) 3302 } 3303 3304 // RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7. 3305 // 3306 // Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool) 3307 func (_DepositManagerI *DepositManagerISession) RequestWithdrawal(rootchain common.Address, amount *big.Int) (*types.Transaction, error) { 3308 return _DepositManagerI.Contract.RequestWithdrawal(&_DepositManagerI.TransactOpts, rootchain, amount) 3309 } 3310 3311 // RequestWithdrawal is a paid mutator transaction binding the contract method 0xda95ebf7. 3312 // 3313 // Solidity: function requestWithdrawal(address rootchain, uint256 amount) returns(bool) 3314 func (_DepositManagerI *DepositManagerITransactorSession) RequestWithdrawal(rootchain common.Address, amount *big.Int) (*types.Transaction, error) { 3315 return _DepositManagerI.Contract.RequestWithdrawal(&_DepositManagerI.TransactOpts, rootchain, amount) 3316 } 3317 3318 // RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7. 3319 // 3320 // Solidity: function requestWithdrawalAll(address rootchain) returns(bool) 3321 func (_DepositManagerI *DepositManagerITransactor) RequestWithdrawalAll(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) { 3322 return _DepositManagerI.contract.Transact(opts, "requestWithdrawalAll", rootchain) 3323 } 3324 3325 // RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7. 3326 // 3327 // Solidity: function requestWithdrawalAll(address rootchain) returns(bool) 3328 func (_DepositManagerI *DepositManagerISession) RequestWithdrawalAll(rootchain common.Address) (*types.Transaction, error) { 3329 return _DepositManagerI.Contract.RequestWithdrawalAll(&_DepositManagerI.TransactOpts, rootchain) 3330 } 3331 3332 // RequestWithdrawalAll is a paid mutator transaction binding the contract method 0x6b2160b7. 3333 // 3334 // Solidity: function requestWithdrawalAll(address rootchain) returns(bool) 3335 func (_DepositManagerI *DepositManagerITransactorSession) RequestWithdrawalAll(rootchain common.Address) (*types.Transaction, error) { 3336 return _DepositManagerI.Contract.RequestWithdrawalAll(&_DepositManagerI.TransactOpts, rootchain) 3337 } 3338 3339 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 3340 // 3341 // Solidity: function setSeigManager(address seigManager) returns() 3342 func (_DepositManagerI *DepositManagerITransactor) SetSeigManager(opts *bind.TransactOpts, seigManager common.Address) (*types.Transaction, error) { 3343 return _DepositManagerI.contract.Transact(opts, "setSeigManager", seigManager) 3344 } 3345 3346 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 3347 // 3348 // Solidity: function setSeigManager(address seigManager) returns() 3349 func (_DepositManagerI *DepositManagerISession) SetSeigManager(seigManager common.Address) (*types.Transaction, error) { 3350 return _DepositManagerI.Contract.SetSeigManager(&_DepositManagerI.TransactOpts, seigManager) 3351 } 3352 3353 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 3354 // 3355 // Solidity: function setSeigManager(address seigManager) returns() 3356 func (_DepositManagerI *DepositManagerITransactorSession) SetSeigManager(seigManager common.Address) (*types.Transaction, error) { 3357 return _DepositManagerI.Contract.SetSeigManager(&_DepositManagerI.TransactOpts, seigManager) 3358 } 3359 3360 // ERC165ABI is the input ABI used to generate the binding from. 3361 const ERC165ABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]" 3362 3363 // ERC165FuncSigs maps the 4-byte function signature to its string representation. 3364 var ERC165FuncSigs = map[string]string{ 3365 "01ffc9a7": "supportsInterface(bytes4)", 3366 } 3367 3368 // ERC165 is an auto generated Go binding around an Ethereum contract. 3369 type ERC165 struct { 3370 ERC165Caller // Read-only binding to the contract 3371 ERC165Transactor // Write-only binding to the contract 3372 ERC165Filterer // Log filterer for contract events 3373 } 3374 3375 // ERC165Caller is an auto generated read-only Go binding around an Ethereum contract. 3376 type ERC165Caller struct { 3377 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3378 } 3379 3380 // ERC165Transactor is an auto generated write-only Go binding around an Ethereum contract. 3381 type ERC165Transactor struct { 3382 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3383 } 3384 3385 // ERC165Filterer is an auto generated log filtering Go binding around an Ethereum contract events. 3386 type ERC165Filterer struct { 3387 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3388 } 3389 3390 // ERC165Session is an auto generated Go binding around an Ethereum contract, 3391 // with pre-set call and transact options. 3392 type ERC165Session struct { 3393 Contract *ERC165 // Generic contract binding to set the session for 3394 CallOpts bind.CallOpts // Call options to use throughout this session 3395 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 3396 } 3397 3398 // ERC165CallerSession is an auto generated read-only Go binding around an Ethereum contract, 3399 // with pre-set call options. 3400 type ERC165CallerSession struct { 3401 Contract *ERC165Caller // Generic contract caller binding to set the session for 3402 CallOpts bind.CallOpts // Call options to use throughout this session 3403 } 3404 3405 // ERC165TransactorSession is an auto generated write-only Go binding around an Ethereum contract, 3406 // with pre-set transact options. 3407 type ERC165TransactorSession struct { 3408 Contract *ERC165Transactor // Generic contract transactor binding to set the session for 3409 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 3410 } 3411 3412 // ERC165Raw is an auto generated low-level Go binding around an Ethereum contract. 3413 type ERC165Raw struct { 3414 Contract *ERC165 // Generic contract binding to access the raw methods on 3415 } 3416 3417 // ERC165CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 3418 type ERC165CallerRaw struct { 3419 Contract *ERC165Caller // Generic read-only contract binding to access the raw methods on 3420 } 3421 3422 // ERC165TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 3423 type ERC165TransactorRaw struct { 3424 Contract *ERC165Transactor // Generic write-only contract binding to access the raw methods on 3425 } 3426 3427 // NewERC165 creates a new instance of ERC165, bound to a specific deployed contract. 3428 func NewERC165(address common.Address, backend bind.ContractBackend) (*ERC165, error) { 3429 contract, err := bindERC165(address, backend, backend, backend) 3430 if err != nil { 3431 return nil, err 3432 } 3433 return &ERC165{ERC165Caller: ERC165Caller{contract: contract}, ERC165Transactor: ERC165Transactor{contract: contract}, ERC165Filterer: ERC165Filterer{contract: contract}}, nil 3434 } 3435 3436 // NewERC165Caller creates a new read-only instance of ERC165, bound to a specific deployed contract. 3437 func NewERC165Caller(address common.Address, caller bind.ContractCaller) (*ERC165Caller, error) { 3438 contract, err := bindERC165(address, caller, nil, nil) 3439 if err != nil { 3440 return nil, err 3441 } 3442 return &ERC165Caller{contract: contract}, nil 3443 } 3444 3445 // NewERC165Transactor creates a new write-only instance of ERC165, bound to a specific deployed contract. 3446 func NewERC165Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC165Transactor, error) { 3447 contract, err := bindERC165(address, nil, transactor, nil) 3448 if err != nil { 3449 return nil, err 3450 } 3451 return &ERC165Transactor{contract: contract}, nil 3452 } 3453 3454 // NewERC165Filterer creates a new log filterer instance of ERC165, bound to a specific deployed contract. 3455 func NewERC165Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC165Filterer, error) { 3456 contract, err := bindERC165(address, nil, nil, filterer) 3457 if err != nil { 3458 return nil, err 3459 } 3460 return &ERC165Filterer{contract: contract}, nil 3461 } 3462 3463 // bindERC165 binds a generic wrapper to an already deployed contract. 3464 func bindERC165(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 3465 parsed, err := abi.JSON(strings.NewReader(ERC165ABI)) 3466 if err != nil { 3467 return nil, err 3468 } 3469 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 3470 } 3471 3472 // Call invokes the (constant) contract method with params as input values and 3473 // sets the output to result. The result type might be a single field for simple 3474 // returns, a slice of interfaces for anonymous returns and a struct for named 3475 // returns. 3476 func (_ERC165 *ERC165Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 3477 return _ERC165.Contract.ERC165Caller.contract.Call(opts, result, method, params...) 3478 } 3479 3480 // Transfer initiates a plain transaction to move funds to the contract, calling 3481 // its default method if one is available. 3482 func (_ERC165 *ERC165Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 3483 return _ERC165.Contract.ERC165Transactor.contract.Transfer(opts) 3484 } 3485 3486 // Transact invokes the (paid) contract method with params as input values. 3487 func (_ERC165 *ERC165Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 3488 return _ERC165.Contract.ERC165Transactor.contract.Transact(opts, method, params...) 3489 } 3490 3491 // Call invokes the (constant) contract method with params as input values and 3492 // sets the output to result. The result type might be a single field for simple 3493 // returns, a slice of interfaces for anonymous returns and a struct for named 3494 // returns. 3495 func (_ERC165 *ERC165CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 3496 return _ERC165.Contract.contract.Call(opts, result, method, params...) 3497 } 3498 3499 // Transfer initiates a plain transaction to move funds to the contract, calling 3500 // its default method if one is available. 3501 func (_ERC165 *ERC165TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 3502 return _ERC165.Contract.contract.Transfer(opts) 3503 } 3504 3505 // Transact invokes the (paid) contract method with params as input values. 3506 func (_ERC165 *ERC165TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 3507 return _ERC165.Contract.contract.Transact(opts, method, params...) 3508 } 3509 3510 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 3511 // 3512 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 3513 func (_ERC165 *ERC165Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { 3514 var ( 3515 ret0 = new(bool) 3516 ) 3517 out := ret0 3518 err := _ERC165.contract.Call(opts, out, "supportsInterface", interfaceId) 3519 return *ret0, err 3520 } 3521 3522 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 3523 // 3524 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 3525 func (_ERC165 *ERC165Session) SupportsInterface(interfaceId [4]byte) (bool, error) { 3526 return _ERC165.Contract.SupportsInterface(&_ERC165.CallOpts, interfaceId) 3527 } 3528 3529 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 3530 // 3531 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 3532 func (_ERC165 *ERC165CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { 3533 return _ERC165.Contract.SupportsInterface(&_ERC165.CallOpts, interfaceId) 3534 } 3535 3536 // ERC165CheckerABI is the input ABI used to generate the binding from. 3537 const ERC165CheckerABI = "[]" 3538 3539 // ERC165CheckerBin is the compiled bytecode used for deploying new contracts. 3540 var ERC165CheckerBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a72315820ea851d268567a3ed8f55b193eb1a6f3028b7565ea2152c791833f991fbaa44e864736f6c634300050c0032" 3541 3542 // DeployERC165Checker deploys a new Ethereum contract, binding an instance of ERC165Checker to it. 3543 func DeployERC165Checker(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC165Checker, error) { 3544 parsed, err := abi.JSON(strings.NewReader(ERC165CheckerABI)) 3545 if err != nil { 3546 return common.Address{}, nil, nil, err 3547 } 3548 3549 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC165CheckerBin), backend) 3550 if err != nil { 3551 return common.Address{}, nil, nil, err 3552 } 3553 return address, tx, &ERC165Checker{ERC165CheckerCaller: ERC165CheckerCaller{contract: contract}, ERC165CheckerTransactor: ERC165CheckerTransactor{contract: contract}, ERC165CheckerFilterer: ERC165CheckerFilterer{contract: contract}}, nil 3554 } 3555 3556 // ERC165Checker is an auto generated Go binding around an Ethereum contract. 3557 type ERC165Checker struct { 3558 ERC165CheckerCaller // Read-only binding to the contract 3559 ERC165CheckerTransactor // Write-only binding to the contract 3560 ERC165CheckerFilterer // Log filterer for contract events 3561 } 3562 3563 // ERC165CheckerCaller is an auto generated read-only Go binding around an Ethereum contract. 3564 type ERC165CheckerCaller struct { 3565 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3566 } 3567 3568 // ERC165CheckerTransactor is an auto generated write-only Go binding around an Ethereum contract. 3569 type ERC165CheckerTransactor struct { 3570 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3571 } 3572 3573 // ERC165CheckerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 3574 type ERC165CheckerFilterer struct { 3575 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3576 } 3577 3578 // ERC165CheckerSession is an auto generated Go binding around an Ethereum contract, 3579 // with pre-set call and transact options. 3580 type ERC165CheckerSession struct { 3581 Contract *ERC165Checker // Generic contract binding to set the session for 3582 CallOpts bind.CallOpts // Call options to use throughout this session 3583 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 3584 } 3585 3586 // ERC165CheckerCallerSession is an auto generated read-only Go binding around an Ethereum contract, 3587 // with pre-set call options. 3588 type ERC165CheckerCallerSession struct { 3589 Contract *ERC165CheckerCaller // Generic contract caller binding to set the session for 3590 CallOpts bind.CallOpts // Call options to use throughout this session 3591 } 3592 3593 // ERC165CheckerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 3594 // with pre-set transact options. 3595 type ERC165CheckerTransactorSession struct { 3596 Contract *ERC165CheckerTransactor // Generic contract transactor binding to set the session for 3597 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 3598 } 3599 3600 // ERC165CheckerRaw is an auto generated low-level Go binding around an Ethereum contract. 3601 type ERC165CheckerRaw struct { 3602 Contract *ERC165Checker // Generic contract binding to access the raw methods on 3603 } 3604 3605 // ERC165CheckerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 3606 type ERC165CheckerCallerRaw struct { 3607 Contract *ERC165CheckerCaller // Generic read-only contract binding to access the raw methods on 3608 } 3609 3610 // ERC165CheckerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 3611 type ERC165CheckerTransactorRaw struct { 3612 Contract *ERC165CheckerTransactor // Generic write-only contract binding to access the raw methods on 3613 } 3614 3615 // NewERC165Checker creates a new instance of ERC165Checker, bound to a specific deployed contract. 3616 func NewERC165Checker(address common.Address, backend bind.ContractBackend) (*ERC165Checker, error) { 3617 contract, err := bindERC165Checker(address, backend, backend, backend) 3618 if err != nil { 3619 return nil, err 3620 } 3621 return &ERC165Checker{ERC165CheckerCaller: ERC165CheckerCaller{contract: contract}, ERC165CheckerTransactor: ERC165CheckerTransactor{contract: contract}, ERC165CheckerFilterer: ERC165CheckerFilterer{contract: contract}}, nil 3622 } 3623 3624 // NewERC165CheckerCaller creates a new read-only instance of ERC165Checker, bound to a specific deployed contract. 3625 func NewERC165CheckerCaller(address common.Address, caller bind.ContractCaller) (*ERC165CheckerCaller, error) { 3626 contract, err := bindERC165Checker(address, caller, nil, nil) 3627 if err != nil { 3628 return nil, err 3629 } 3630 return &ERC165CheckerCaller{contract: contract}, nil 3631 } 3632 3633 // NewERC165CheckerTransactor creates a new write-only instance of ERC165Checker, bound to a specific deployed contract. 3634 func NewERC165CheckerTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC165CheckerTransactor, error) { 3635 contract, err := bindERC165Checker(address, nil, transactor, nil) 3636 if err != nil { 3637 return nil, err 3638 } 3639 return &ERC165CheckerTransactor{contract: contract}, nil 3640 } 3641 3642 // NewERC165CheckerFilterer creates a new log filterer instance of ERC165Checker, bound to a specific deployed contract. 3643 func NewERC165CheckerFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC165CheckerFilterer, error) { 3644 contract, err := bindERC165Checker(address, nil, nil, filterer) 3645 if err != nil { 3646 return nil, err 3647 } 3648 return &ERC165CheckerFilterer{contract: contract}, nil 3649 } 3650 3651 // bindERC165Checker binds a generic wrapper to an already deployed contract. 3652 func bindERC165Checker(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 3653 parsed, err := abi.JSON(strings.NewReader(ERC165CheckerABI)) 3654 if err != nil { 3655 return nil, err 3656 } 3657 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 3658 } 3659 3660 // Call invokes the (constant) contract method with params as input values and 3661 // sets the output to result. The result type might be a single field for simple 3662 // returns, a slice of interfaces for anonymous returns and a struct for named 3663 // returns. 3664 func (_ERC165Checker *ERC165CheckerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 3665 return _ERC165Checker.Contract.ERC165CheckerCaller.contract.Call(opts, result, method, params...) 3666 } 3667 3668 // Transfer initiates a plain transaction to move funds to the contract, calling 3669 // its default method if one is available. 3670 func (_ERC165Checker *ERC165CheckerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 3671 return _ERC165Checker.Contract.ERC165CheckerTransactor.contract.Transfer(opts) 3672 } 3673 3674 // Transact invokes the (paid) contract method with params as input values. 3675 func (_ERC165Checker *ERC165CheckerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 3676 return _ERC165Checker.Contract.ERC165CheckerTransactor.contract.Transact(opts, method, params...) 3677 } 3678 3679 // Call invokes the (constant) contract method with params as input values and 3680 // sets the output to result. The result type might be a single field for simple 3681 // returns, a slice of interfaces for anonymous returns and a struct for named 3682 // returns. 3683 func (_ERC165Checker *ERC165CheckerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 3684 return _ERC165Checker.Contract.contract.Call(opts, result, method, params...) 3685 } 3686 3687 // Transfer initiates a plain transaction to move funds to the contract, calling 3688 // its default method if one is available. 3689 func (_ERC165Checker *ERC165CheckerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 3690 return _ERC165Checker.Contract.contract.Transfer(opts) 3691 } 3692 3693 // Transact invokes the (paid) contract method with params as input values. 3694 func (_ERC165Checker *ERC165CheckerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 3695 return _ERC165Checker.Contract.contract.Transact(opts, method, params...) 3696 } 3697 3698 // ERC20ABI is the input ABI used to generate the binding from. 3699 const ERC20ABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"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\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 3700 3701 // ERC20FuncSigs maps the 4-byte function signature to its string representation. 3702 var ERC20FuncSigs = map[string]string{ 3703 "dd62ed3e": "allowance(address,address)", 3704 "095ea7b3": "approve(address,uint256)", 3705 "70a08231": "balanceOf(address)", 3706 "a457c2d7": "decreaseAllowance(address,uint256)", 3707 "39509351": "increaseAllowance(address,uint256)", 3708 "18160ddd": "totalSupply()", 3709 "a9059cbb": "transfer(address,uint256)", 3710 "23b872dd": "transferFrom(address,address,uint256)", 3711 } 3712 3713 // ERC20Bin is the compiled bytecode used for deploying new contracts. 3714 var ERC20Bin = "0x608060405261083b806100136000396000f3fe608060405234801561001057600080fd5b50600436106100885760003560e01c806370a082311161005b57806370a0823114610149578063a457c2d71461016f578063a9059cbb1461019b578063dd62ed3e146101c757610088565b8063095ea7b31461008d57806318160ddd146100cd57806323b872dd146100e7578063395093511461011d575b600080fd5b6100b9600480360360408110156100a357600080fd5b506001600160a01b0381351690602001356101f5565b604080519115158252519081900360200190f35b6100d5610212565b60408051918252519081900360200190f35b6100b9600480360360608110156100fd57600080fd5b506001600160a01b03813581169160208101359091169060400135610218565b6100b96004803603604081101561013357600080fd5b506001600160a01b0381351690602001356102a5565b6100d56004803603602081101561015f57600080fd5b50356001600160a01b03166102f9565b6100b96004803603604081101561018557600080fd5b506001600160a01b038135169060200135610314565b6100b9600480360360408110156101b157600080fd5b506001600160a01b038135169060200135610382565b6100d5600480360360408110156101dd57600080fd5b506001600160a01b0381358116916020013516610396565b60006102096102026103c1565b84846103c5565b50600192915050565b60025490565b60006102258484846104b1565b61029b846102316103c1565b61029685604051806060016040528060288152602001610771602891396001600160a01b038a1660009081526001602052604081209061026f6103c1565b6001600160a01b03168152602081019190915260400160002054919063ffffffff61060d16565b6103c5565b5060019392505050565b60006102096102b26103c1565b8461029685600160006102c36103c1565b6001600160a01b03908116825260208083019390935260409182016000908120918c16815292529020549063ffffffff6106a416565b6001600160a01b031660009081526020819052604090205490565b60006102096103216103c1565b84610296856040518060600160405280602581526020016107e2602591396001600061034b6103c1565b6001600160a01b03908116825260208083019390935260409182016000908120918d1681529252902054919063ffffffff61060d16565b600061020961038f6103c1565b84846104b1565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b3390565b6001600160a01b03831661040a5760405162461bcd60e51b81526004018080602001828103825260248152602001806107be6024913960400191505060405180910390fd5b6001600160a01b03821661044f5760405162461bcd60e51b81526004018080602001828103825260228152602001806107296022913960400191505060405180910390fd5b6001600160a01b03808416600081815260016020908152604080832094871680845294825291829020859055815185815291517f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259281900390910190a3505050565b6001600160a01b0383166104f65760405162461bcd60e51b81526004018080602001828103825260258152602001806107996025913960400191505060405180910390fd5b6001600160a01b03821661053b5760405162461bcd60e51b81526004018080602001828103825260238152602001806107066023913960400191505060405180910390fd5b61057e8160405180606001604052806026815260200161074b602691396001600160a01b038616600090815260208190526040902054919063ffffffff61060d16565b6001600160a01b0380851660009081526020819052604080822093909355908416815220546105b3908263ffffffff6106a416565b6001600160a01b038084166000818152602081815260409182902094909455805185815290519193928716927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef92918290030190a3505050565b6000818484111561069c5760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b83811015610661578181015183820152602001610649565b50505050905090810190601f16801561068e5780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b505050900390565b6000828201838110156106fe576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b939250505056fe45524332303a207472616e7366657220746f20746865207a65726f206164647265737345524332303a20617070726f766520746f20746865207a65726f206164647265737345524332303a207472616e7366657220616d6f756e7420657863656564732062616c616e636545524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e636545524332303a207472616e736665722066726f6d20746865207a65726f206164647265737345524332303a20617070726f76652066726f6d20746865207a65726f206164647265737345524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726fa265627a7a7231582008ca9864b08faad547b35ef43549788be26de128b59e0167fefa4ac97cd6733964736f6c634300050c0032" 3715 3716 // DeployERC20 deploys a new Ethereum contract, binding an instance of ERC20 to it. 3717 func DeployERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20, error) { 3718 parsed, err := abi.JSON(strings.NewReader(ERC20ABI)) 3719 if err != nil { 3720 return common.Address{}, nil, nil, err 3721 } 3722 3723 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20Bin), backend) 3724 if err != nil { 3725 return common.Address{}, nil, nil, err 3726 } 3727 return address, tx, &ERC20{ERC20Caller: ERC20Caller{contract: contract}, ERC20Transactor: ERC20Transactor{contract: contract}, ERC20Filterer: ERC20Filterer{contract: contract}}, nil 3728 } 3729 3730 // ERC20 is an auto generated Go binding around an Ethereum contract. 3731 type ERC20 struct { 3732 ERC20Caller // Read-only binding to the contract 3733 ERC20Transactor // Write-only binding to the contract 3734 ERC20Filterer // Log filterer for contract events 3735 } 3736 3737 // ERC20Caller is an auto generated read-only Go binding around an Ethereum contract. 3738 type ERC20Caller struct { 3739 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3740 } 3741 3742 // ERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. 3743 type ERC20Transactor struct { 3744 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3745 } 3746 3747 // ERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. 3748 type ERC20Filterer struct { 3749 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3750 } 3751 3752 // ERC20Session is an auto generated Go binding around an Ethereum contract, 3753 // with pre-set call and transact options. 3754 type ERC20Session struct { 3755 Contract *ERC20 // Generic contract binding to set the session for 3756 CallOpts bind.CallOpts // Call options to use throughout this session 3757 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 3758 } 3759 3760 // ERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, 3761 // with pre-set call options. 3762 type ERC20CallerSession struct { 3763 Contract *ERC20Caller // Generic contract caller binding to set the session for 3764 CallOpts bind.CallOpts // Call options to use throughout this session 3765 } 3766 3767 // ERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, 3768 // with pre-set transact options. 3769 type ERC20TransactorSession struct { 3770 Contract *ERC20Transactor // Generic contract transactor binding to set the session for 3771 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 3772 } 3773 3774 // ERC20Raw is an auto generated low-level Go binding around an Ethereum contract. 3775 type ERC20Raw struct { 3776 Contract *ERC20 // Generic contract binding to access the raw methods on 3777 } 3778 3779 // ERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 3780 type ERC20CallerRaw struct { 3781 Contract *ERC20Caller // Generic read-only contract binding to access the raw methods on 3782 } 3783 3784 // ERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 3785 type ERC20TransactorRaw struct { 3786 Contract *ERC20Transactor // Generic write-only contract binding to access the raw methods on 3787 } 3788 3789 // NewERC20 creates a new instance of ERC20, bound to a specific deployed contract. 3790 func NewERC20(address common.Address, backend bind.ContractBackend) (*ERC20, error) { 3791 contract, err := bindERC20(address, backend, backend, backend) 3792 if err != nil { 3793 return nil, err 3794 } 3795 return &ERC20{ERC20Caller: ERC20Caller{contract: contract}, ERC20Transactor: ERC20Transactor{contract: contract}, ERC20Filterer: ERC20Filterer{contract: contract}}, nil 3796 } 3797 3798 // NewERC20Caller creates a new read-only instance of ERC20, bound to a specific deployed contract. 3799 func NewERC20Caller(address common.Address, caller bind.ContractCaller) (*ERC20Caller, error) { 3800 contract, err := bindERC20(address, caller, nil, nil) 3801 if err != nil { 3802 return nil, err 3803 } 3804 return &ERC20Caller{contract: contract}, nil 3805 } 3806 3807 // NewERC20Transactor creates a new write-only instance of ERC20, bound to a specific deployed contract. 3808 func NewERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC20Transactor, error) { 3809 contract, err := bindERC20(address, nil, transactor, nil) 3810 if err != nil { 3811 return nil, err 3812 } 3813 return &ERC20Transactor{contract: contract}, nil 3814 } 3815 3816 // NewERC20Filterer creates a new log filterer instance of ERC20, bound to a specific deployed contract. 3817 func NewERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC20Filterer, error) { 3818 contract, err := bindERC20(address, nil, nil, filterer) 3819 if err != nil { 3820 return nil, err 3821 } 3822 return &ERC20Filterer{contract: contract}, nil 3823 } 3824 3825 // bindERC20 binds a generic wrapper to an already deployed contract. 3826 func bindERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 3827 parsed, err := abi.JSON(strings.NewReader(ERC20ABI)) 3828 if err != nil { 3829 return nil, err 3830 } 3831 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 3832 } 3833 3834 // Call invokes the (constant) contract method with params as input values and 3835 // sets the output to result. The result type might be a single field for simple 3836 // returns, a slice of interfaces for anonymous returns and a struct for named 3837 // returns. 3838 func (_ERC20 *ERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 3839 return _ERC20.Contract.ERC20Caller.contract.Call(opts, result, method, params...) 3840 } 3841 3842 // Transfer initiates a plain transaction to move funds to the contract, calling 3843 // its default method if one is available. 3844 func (_ERC20 *ERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 3845 return _ERC20.Contract.ERC20Transactor.contract.Transfer(opts) 3846 } 3847 3848 // Transact invokes the (paid) contract method with params as input values. 3849 func (_ERC20 *ERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 3850 return _ERC20.Contract.ERC20Transactor.contract.Transact(opts, method, params...) 3851 } 3852 3853 // Call invokes the (constant) contract method with params as input values and 3854 // sets the output to result. The result type might be a single field for simple 3855 // returns, a slice of interfaces for anonymous returns and a struct for named 3856 // returns. 3857 func (_ERC20 *ERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 3858 return _ERC20.Contract.contract.Call(opts, result, method, params...) 3859 } 3860 3861 // Transfer initiates a plain transaction to move funds to the contract, calling 3862 // its default method if one is available. 3863 func (_ERC20 *ERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 3864 return _ERC20.Contract.contract.Transfer(opts) 3865 } 3866 3867 // Transact invokes the (paid) contract method with params as input values. 3868 func (_ERC20 *ERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 3869 return _ERC20.Contract.contract.Transact(opts, method, params...) 3870 } 3871 3872 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 3873 // 3874 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 3875 func (_ERC20 *ERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 3876 var ( 3877 ret0 = new(*big.Int) 3878 ) 3879 out := ret0 3880 err := _ERC20.contract.Call(opts, out, "allowance", owner, spender) 3881 return *ret0, err 3882 } 3883 3884 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 3885 // 3886 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 3887 func (_ERC20 *ERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 3888 return _ERC20.Contract.Allowance(&_ERC20.CallOpts, owner, spender) 3889 } 3890 3891 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 3892 // 3893 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 3894 func (_ERC20 *ERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 3895 return _ERC20.Contract.Allowance(&_ERC20.CallOpts, owner, spender) 3896 } 3897 3898 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 3899 // 3900 // Solidity: function balanceOf(address account) constant returns(uint256) 3901 func (_ERC20 *ERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 3902 var ( 3903 ret0 = new(*big.Int) 3904 ) 3905 out := ret0 3906 err := _ERC20.contract.Call(opts, out, "balanceOf", account) 3907 return *ret0, err 3908 } 3909 3910 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 3911 // 3912 // Solidity: function balanceOf(address account) constant returns(uint256) 3913 func (_ERC20 *ERC20Session) BalanceOf(account common.Address) (*big.Int, error) { 3914 return _ERC20.Contract.BalanceOf(&_ERC20.CallOpts, account) 3915 } 3916 3917 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 3918 // 3919 // Solidity: function balanceOf(address account) constant returns(uint256) 3920 func (_ERC20 *ERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { 3921 return _ERC20.Contract.BalanceOf(&_ERC20.CallOpts, account) 3922 } 3923 3924 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 3925 // 3926 // Solidity: function totalSupply() constant returns(uint256) 3927 func (_ERC20 *ERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 3928 var ( 3929 ret0 = new(*big.Int) 3930 ) 3931 out := ret0 3932 err := _ERC20.contract.Call(opts, out, "totalSupply") 3933 return *ret0, err 3934 } 3935 3936 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 3937 // 3938 // Solidity: function totalSupply() constant returns(uint256) 3939 func (_ERC20 *ERC20Session) TotalSupply() (*big.Int, error) { 3940 return _ERC20.Contract.TotalSupply(&_ERC20.CallOpts) 3941 } 3942 3943 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 3944 // 3945 // Solidity: function totalSupply() constant returns(uint256) 3946 func (_ERC20 *ERC20CallerSession) TotalSupply() (*big.Int, error) { 3947 return _ERC20.Contract.TotalSupply(&_ERC20.CallOpts) 3948 } 3949 3950 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 3951 // 3952 // Solidity: function approve(address spender, uint256 amount) returns(bool) 3953 func (_ERC20 *ERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 3954 return _ERC20.contract.Transact(opts, "approve", spender, amount) 3955 } 3956 3957 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 3958 // 3959 // Solidity: function approve(address spender, uint256 amount) returns(bool) 3960 func (_ERC20 *ERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 3961 return _ERC20.Contract.Approve(&_ERC20.TransactOpts, spender, amount) 3962 } 3963 3964 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 3965 // 3966 // Solidity: function approve(address spender, uint256 amount) returns(bool) 3967 func (_ERC20 *ERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 3968 return _ERC20.Contract.Approve(&_ERC20.TransactOpts, spender, amount) 3969 } 3970 3971 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 3972 // 3973 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 3974 func (_ERC20 *ERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 3975 return _ERC20.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) 3976 } 3977 3978 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 3979 // 3980 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 3981 func (_ERC20 *ERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 3982 return _ERC20.Contract.DecreaseAllowance(&_ERC20.TransactOpts, spender, subtractedValue) 3983 } 3984 3985 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 3986 // 3987 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 3988 func (_ERC20 *ERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 3989 return _ERC20.Contract.DecreaseAllowance(&_ERC20.TransactOpts, spender, subtractedValue) 3990 } 3991 3992 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 3993 // 3994 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 3995 func (_ERC20 *ERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 3996 return _ERC20.contract.Transact(opts, "increaseAllowance", spender, addedValue) 3997 } 3998 3999 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 4000 // 4001 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 4002 func (_ERC20 *ERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 4003 return _ERC20.Contract.IncreaseAllowance(&_ERC20.TransactOpts, spender, addedValue) 4004 } 4005 4006 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 4007 // 4008 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 4009 func (_ERC20 *ERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 4010 return _ERC20.Contract.IncreaseAllowance(&_ERC20.TransactOpts, spender, addedValue) 4011 } 4012 4013 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 4014 // 4015 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 4016 func (_ERC20 *ERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4017 return _ERC20.contract.Transact(opts, "transfer", recipient, amount) 4018 } 4019 4020 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 4021 // 4022 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 4023 func (_ERC20 *ERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4024 return _ERC20.Contract.Transfer(&_ERC20.TransactOpts, recipient, amount) 4025 } 4026 4027 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 4028 // 4029 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 4030 func (_ERC20 *ERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4031 return _ERC20.Contract.Transfer(&_ERC20.TransactOpts, recipient, amount) 4032 } 4033 4034 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 4035 // 4036 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 4037 func (_ERC20 *ERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4038 return _ERC20.contract.Transact(opts, "transferFrom", sender, recipient, amount) 4039 } 4040 4041 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 4042 // 4043 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 4044 func (_ERC20 *ERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4045 return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, sender, recipient, amount) 4046 } 4047 4048 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 4049 // 4050 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 4051 func (_ERC20 *ERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4052 return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, sender, recipient, amount) 4053 } 4054 4055 // ERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20 contract. 4056 type ERC20ApprovalIterator struct { 4057 Event *ERC20Approval // Event containing the contract specifics and raw log 4058 4059 contract *bind.BoundContract // Generic contract to use for unpacking event data 4060 event string // Event name to use for unpacking event data 4061 4062 logs chan types.Log // Log channel receiving the found contract events 4063 sub ethereum.Subscription // Subscription for errors, completion and termination 4064 done bool // Whether the subscription completed delivering logs 4065 fail error // Occurred error to stop iteration 4066 } 4067 4068 // Next advances the iterator to the subsequent event, returning whether there 4069 // are any more events found. In case of a retrieval or parsing error, false is 4070 // returned and Error() can be queried for the exact failure. 4071 func (it *ERC20ApprovalIterator) Next() bool { 4072 // If the iterator failed, stop iterating 4073 if it.fail != nil { 4074 return false 4075 } 4076 // If the iterator completed, deliver directly whatever's available 4077 if it.done { 4078 select { 4079 case log := <-it.logs: 4080 it.Event = new(ERC20Approval) 4081 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4082 it.fail = err 4083 return false 4084 } 4085 it.Event.Raw = log 4086 return true 4087 4088 default: 4089 return false 4090 } 4091 } 4092 // Iterator still in progress, wait for either a data or an error event 4093 select { 4094 case log := <-it.logs: 4095 it.Event = new(ERC20Approval) 4096 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4097 it.fail = err 4098 return false 4099 } 4100 it.Event.Raw = log 4101 return true 4102 4103 case err := <-it.sub.Err(): 4104 it.done = true 4105 it.fail = err 4106 return it.Next() 4107 } 4108 } 4109 4110 // Error returns any retrieval or parsing error occurred during filtering. 4111 func (it *ERC20ApprovalIterator) Error() error { 4112 return it.fail 4113 } 4114 4115 // Close terminates the iteration process, releasing any pending underlying 4116 // resources. 4117 func (it *ERC20ApprovalIterator) Close() error { 4118 it.sub.Unsubscribe() 4119 return nil 4120 } 4121 4122 // ERC20Approval represents a Approval event raised by the ERC20 contract. 4123 type ERC20Approval struct { 4124 Owner common.Address 4125 Spender common.Address 4126 Value *big.Int 4127 Raw types.Log // Blockchain specific contextual infos 4128 } 4129 4130 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 4131 // 4132 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 4133 func (_ERC20 *ERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20ApprovalIterator, error) { 4134 4135 var ownerRule []interface{} 4136 for _, ownerItem := range owner { 4137 ownerRule = append(ownerRule, ownerItem) 4138 } 4139 var spenderRule []interface{} 4140 for _, spenderItem := range spender { 4141 spenderRule = append(spenderRule, spenderItem) 4142 } 4143 4144 logs, sub, err := _ERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 4145 if err != nil { 4146 return nil, err 4147 } 4148 return &ERC20ApprovalIterator{contract: _ERC20.contract, event: "Approval", logs: logs, sub: sub}, nil 4149 } 4150 4151 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 4152 // 4153 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 4154 func (_ERC20 *ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 4155 4156 var ownerRule []interface{} 4157 for _, ownerItem := range owner { 4158 ownerRule = append(ownerRule, ownerItem) 4159 } 4160 var spenderRule []interface{} 4161 for _, spenderItem := range spender { 4162 spenderRule = append(spenderRule, spenderItem) 4163 } 4164 4165 logs, sub, err := _ERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 4166 if err != nil { 4167 return nil, err 4168 } 4169 return event.NewSubscription(func(quit <-chan struct{}) error { 4170 defer sub.Unsubscribe() 4171 for { 4172 select { 4173 case log := <-logs: 4174 // New log arrived, parse the event and forward to the user 4175 event := new(ERC20Approval) 4176 if err := _ERC20.contract.UnpackLog(event, "Approval", log); err != nil { 4177 return err 4178 } 4179 event.Raw = log 4180 4181 select { 4182 case sink <- event: 4183 case err := <-sub.Err(): 4184 return err 4185 case <-quit: 4186 return nil 4187 } 4188 case err := <-sub.Err(): 4189 return err 4190 case <-quit: 4191 return nil 4192 } 4193 } 4194 }), nil 4195 } 4196 4197 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 4198 // 4199 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 4200 func (_ERC20 *ERC20Filterer) ParseApproval(log types.Log) (*ERC20Approval, error) { 4201 event := new(ERC20Approval) 4202 if err := _ERC20.contract.UnpackLog(event, "Approval", log); err != nil { 4203 return nil, err 4204 } 4205 return event, nil 4206 } 4207 4208 // ERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20 contract. 4209 type ERC20TransferIterator struct { 4210 Event *ERC20Transfer // Event containing the contract specifics and raw log 4211 4212 contract *bind.BoundContract // Generic contract to use for unpacking event data 4213 event string // Event name to use for unpacking event data 4214 4215 logs chan types.Log // Log channel receiving the found contract events 4216 sub ethereum.Subscription // Subscription for errors, completion and termination 4217 done bool // Whether the subscription completed delivering logs 4218 fail error // Occurred error to stop iteration 4219 } 4220 4221 // Next advances the iterator to the subsequent event, returning whether there 4222 // are any more events found. In case of a retrieval or parsing error, false is 4223 // returned and Error() can be queried for the exact failure. 4224 func (it *ERC20TransferIterator) Next() bool { 4225 // If the iterator failed, stop iterating 4226 if it.fail != nil { 4227 return false 4228 } 4229 // If the iterator completed, deliver directly whatever's available 4230 if it.done { 4231 select { 4232 case log := <-it.logs: 4233 it.Event = new(ERC20Transfer) 4234 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4235 it.fail = err 4236 return false 4237 } 4238 it.Event.Raw = log 4239 return true 4240 4241 default: 4242 return false 4243 } 4244 } 4245 // Iterator still in progress, wait for either a data or an error event 4246 select { 4247 case log := <-it.logs: 4248 it.Event = new(ERC20Transfer) 4249 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4250 it.fail = err 4251 return false 4252 } 4253 it.Event.Raw = log 4254 return true 4255 4256 case err := <-it.sub.Err(): 4257 it.done = true 4258 it.fail = err 4259 return it.Next() 4260 } 4261 } 4262 4263 // Error returns any retrieval or parsing error occurred during filtering. 4264 func (it *ERC20TransferIterator) Error() error { 4265 return it.fail 4266 } 4267 4268 // Close terminates the iteration process, releasing any pending underlying 4269 // resources. 4270 func (it *ERC20TransferIterator) Close() error { 4271 it.sub.Unsubscribe() 4272 return nil 4273 } 4274 4275 // ERC20Transfer represents a Transfer event raised by the ERC20 contract. 4276 type ERC20Transfer struct { 4277 From common.Address 4278 To common.Address 4279 Value *big.Int 4280 Raw types.Log // Blockchain specific contextual infos 4281 } 4282 4283 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 4284 // 4285 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 4286 func (_ERC20 *ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20TransferIterator, error) { 4287 4288 var fromRule []interface{} 4289 for _, fromItem := range from { 4290 fromRule = append(fromRule, fromItem) 4291 } 4292 var toRule []interface{} 4293 for _, toItem := range to { 4294 toRule = append(toRule, toItem) 4295 } 4296 4297 logs, sub, err := _ERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 4298 if err != nil { 4299 return nil, err 4300 } 4301 return &ERC20TransferIterator{contract: _ERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil 4302 } 4303 4304 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 4305 // 4306 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 4307 func (_ERC20 *ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { 4308 4309 var fromRule []interface{} 4310 for _, fromItem := range from { 4311 fromRule = append(fromRule, fromItem) 4312 } 4313 var toRule []interface{} 4314 for _, toItem := range to { 4315 toRule = append(toRule, toItem) 4316 } 4317 4318 logs, sub, err := _ERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 4319 if err != nil { 4320 return nil, err 4321 } 4322 return event.NewSubscription(func(quit <-chan struct{}) error { 4323 defer sub.Unsubscribe() 4324 for { 4325 select { 4326 case log := <-logs: 4327 // New log arrived, parse the event and forward to the user 4328 event := new(ERC20Transfer) 4329 if err := _ERC20.contract.UnpackLog(event, "Transfer", log); err != nil { 4330 return err 4331 } 4332 event.Raw = log 4333 4334 select { 4335 case sink <- event: 4336 case err := <-sub.Err(): 4337 return err 4338 case <-quit: 4339 return nil 4340 } 4341 case err := <-sub.Err(): 4342 return err 4343 case <-quit: 4344 return nil 4345 } 4346 } 4347 }), nil 4348 } 4349 4350 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 4351 // 4352 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 4353 func (_ERC20 *ERC20Filterer) ParseTransfer(log types.Log) (*ERC20Transfer, error) { 4354 event := new(ERC20Transfer) 4355 if err := _ERC20.contract.UnpackLog(event, "Transfer", log); err != nil { 4356 return nil, err 4357 } 4358 return event, nil 4359 } 4360 4361 // ERC20BurnableABI is the input ABI used to generate the binding from. 4362 const ERC20BurnableABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burnFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"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\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 4363 4364 // ERC20BurnableFuncSigs maps the 4-byte function signature to its string representation. 4365 var ERC20BurnableFuncSigs = map[string]string{ 4366 "dd62ed3e": "allowance(address,address)", 4367 "095ea7b3": "approve(address,uint256)", 4368 "70a08231": "balanceOf(address)", 4369 "42966c68": "burn(uint256)", 4370 "79cc6790": "burnFrom(address,uint256)", 4371 "a457c2d7": "decreaseAllowance(address,uint256)", 4372 "39509351": "increaseAllowance(address,uint256)", 4373 "18160ddd": "totalSupply()", 4374 "a9059cbb": "transfer(address,uint256)", 4375 "23b872dd": "transferFrom(address,address,uint256)", 4376 } 4377 4378 // ERC20BurnableBin is the compiled bytecode used for deploying new contracts. 4379 var ERC20BurnableBin = "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" 4380 4381 // DeployERC20Burnable deploys a new Ethereum contract, binding an instance of ERC20Burnable to it. 4382 func DeployERC20Burnable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20Burnable, error) { 4383 parsed, err := abi.JSON(strings.NewReader(ERC20BurnableABI)) 4384 if err != nil { 4385 return common.Address{}, nil, nil, err 4386 } 4387 4388 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20BurnableBin), backend) 4389 if err != nil { 4390 return common.Address{}, nil, nil, err 4391 } 4392 return address, tx, &ERC20Burnable{ERC20BurnableCaller: ERC20BurnableCaller{contract: contract}, ERC20BurnableTransactor: ERC20BurnableTransactor{contract: contract}, ERC20BurnableFilterer: ERC20BurnableFilterer{contract: contract}}, nil 4393 } 4394 4395 // ERC20Burnable is an auto generated Go binding around an Ethereum contract. 4396 type ERC20Burnable struct { 4397 ERC20BurnableCaller // Read-only binding to the contract 4398 ERC20BurnableTransactor // Write-only binding to the contract 4399 ERC20BurnableFilterer // Log filterer for contract events 4400 } 4401 4402 // ERC20BurnableCaller is an auto generated read-only Go binding around an Ethereum contract. 4403 type ERC20BurnableCaller struct { 4404 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4405 } 4406 4407 // ERC20BurnableTransactor is an auto generated write-only Go binding around an Ethereum contract. 4408 type ERC20BurnableTransactor struct { 4409 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4410 } 4411 4412 // ERC20BurnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 4413 type ERC20BurnableFilterer struct { 4414 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4415 } 4416 4417 // ERC20BurnableSession is an auto generated Go binding around an Ethereum contract, 4418 // with pre-set call and transact options. 4419 type ERC20BurnableSession struct { 4420 Contract *ERC20Burnable // Generic contract binding to set the session for 4421 CallOpts bind.CallOpts // Call options to use throughout this session 4422 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 4423 } 4424 4425 // ERC20BurnableCallerSession is an auto generated read-only Go binding around an Ethereum contract, 4426 // with pre-set call options. 4427 type ERC20BurnableCallerSession struct { 4428 Contract *ERC20BurnableCaller // Generic contract caller binding to set the session for 4429 CallOpts bind.CallOpts // Call options to use throughout this session 4430 } 4431 4432 // ERC20BurnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 4433 // with pre-set transact options. 4434 type ERC20BurnableTransactorSession struct { 4435 Contract *ERC20BurnableTransactor // Generic contract transactor binding to set the session for 4436 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 4437 } 4438 4439 // ERC20BurnableRaw is an auto generated low-level Go binding around an Ethereum contract. 4440 type ERC20BurnableRaw struct { 4441 Contract *ERC20Burnable // Generic contract binding to access the raw methods on 4442 } 4443 4444 // ERC20BurnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 4445 type ERC20BurnableCallerRaw struct { 4446 Contract *ERC20BurnableCaller // Generic read-only contract binding to access the raw methods on 4447 } 4448 4449 // ERC20BurnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 4450 type ERC20BurnableTransactorRaw struct { 4451 Contract *ERC20BurnableTransactor // Generic write-only contract binding to access the raw methods on 4452 } 4453 4454 // NewERC20Burnable creates a new instance of ERC20Burnable, bound to a specific deployed contract. 4455 func NewERC20Burnable(address common.Address, backend bind.ContractBackend) (*ERC20Burnable, error) { 4456 contract, err := bindERC20Burnable(address, backend, backend, backend) 4457 if err != nil { 4458 return nil, err 4459 } 4460 return &ERC20Burnable{ERC20BurnableCaller: ERC20BurnableCaller{contract: contract}, ERC20BurnableTransactor: ERC20BurnableTransactor{contract: contract}, ERC20BurnableFilterer: ERC20BurnableFilterer{contract: contract}}, nil 4461 } 4462 4463 // NewERC20BurnableCaller creates a new read-only instance of ERC20Burnable, bound to a specific deployed contract. 4464 func NewERC20BurnableCaller(address common.Address, caller bind.ContractCaller) (*ERC20BurnableCaller, error) { 4465 contract, err := bindERC20Burnable(address, caller, nil, nil) 4466 if err != nil { 4467 return nil, err 4468 } 4469 return &ERC20BurnableCaller{contract: contract}, nil 4470 } 4471 4472 // NewERC20BurnableTransactor creates a new write-only instance of ERC20Burnable, bound to a specific deployed contract. 4473 func NewERC20BurnableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20BurnableTransactor, error) { 4474 contract, err := bindERC20Burnable(address, nil, transactor, nil) 4475 if err != nil { 4476 return nil, err 4477 } 4478 return &ERC20BurnableTransactor{contract: contract}, nil 4479 } 4480 4481 // NewERC20BurnableFilterer creates a new log filterer instance of ERC20Burnable, bound to a specific deployed contract. 4482 func NewERC20BurnableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20BurnableFilterer, error) { 4483 contract, err := bindERC20Burnable(address, nil, nil, filterer) 4484 if err != nil { 4485 return nil, err 4486 } 4487 return &ERC20BurnableFilterer{contract: contract}, nil 4488 } 4489 4490 // bindERC20Burnable binds a generic wrapper to an already deployed contract. 4491 func bindERC20Burnable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 4492 parsed, err := abi.JSON(strings.NewReader(ERC20BurnableABI)) 4493 if err != nil { 4494 return nil, err 4495 } 4496 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 4497 } 4498 4499 // Call invokes the (constant) contract method with params as input values and 4500 // sets the output to result. The result type might be a single field for simple 4501 // returns, a slice of interfaces for anonymous returns and a struct for named 4502 // returns. 4503 func (_ERC20Burnable *ERC20BurnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 4504 return _ERC20Burnable.Contract.ERC20BurnableCaller.contract.Call(opts, result, method, params...) 4505 } 4506 4507 // Transfer initiates a plain transaction to move funds to the contract, calling 4508 // its default method if one is available. 4509 func (_ERC20Burnable *ERC20BurnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 4510 return _ERC20Burnable.Contract.ERC20BurnableTransactor.contract.Transfer(opts) 4511 } 4512 4513 // Transact invokes the (paid) contract method with params as input values. 4514 func (_ERC20Burnable *ERC20BurnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 4515 return _ERC20Burnable.Contract.ERC20BurnableTransactor.contract.Transact(opts, method, params...) 4516 } 4517 4518 // Call invokes the (constant) contract method with params as input values and 4519 // sets the output to result. The result type might be a single field for simple 4520 // returns, a slice of interfaces for anonymous returns and a struct for named 4521 // returns. 4522 func (_ERC20Burnable *ERC20BurnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 4523 return _ERC20Burnable.Contract.contract.Call(opts, result, method, params...) 4524 } 4525 4526 // Transfer initiates a plain transaction to move funds to the contract, calling 4527 // its default method if one is available. 4528 func (_ERC20Burnable *ERC20BurnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 4529 return _ERC20Burnable.Contract.contract.Transfer(opts) 4530 } 4531 4532 // Transact invokes the (paid) contract method with params as input values. 4533 func (_ERC20Burnable *ERC20BurnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 4534 return _ERC20Burnable.Contract.contract.Transact(opts, method, params...) 4535 } 4536 4537 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 4538 // 4539 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 4540 func (_ERC20Burnable *ERC20BurnableCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 4541 var ( 4542 ret0 = new(*big.Int) 4543 ) 4544 out := ret0 4545 err := _ERC20Burnable.contract.Call(opts, out, "allowance", owner, spender) 4546 return *ret0, err 4547 } 4548 4549 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 4550 // 4551 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 4552 func (_ERC20Burnable *ERC20BurnableSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 4553 return _ERC20Burnable.Contract.Allowance(&_ERC20Burnable.CallOpts, owner, spender) 4554 } 4555 4556 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 4557 // 4558 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 4559 func (_ERC20Burnable *ERC20BurnableCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 4560 return _ERC20Burnable.Contract.Allowance(&_ERC20Burnable.CallOpts, owner, spender) 4561 } 4562 4563 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 4564 // 4565 // Solidity: function balanceOf(address account) constant returns(uint256) 4566 func (_ERC20Burnable *ERC20BurnableCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 4567 var ( 4568 ret0 = new(*big.Int) 4569 ) 4570 out := ret0 4571 err := _ERC20Burnable.contract.Call(opts, out, "balanceOf", account) 4572 return *ret0, err 4573 } 4574 4575 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 4576 // 4577 // Solidity: function balanceOf(address account) constant returns(uint256) 4578 func (_ERC20Burnable *ERC20BurnableSession) BalanceOf(account common.Address) (*big.Int, error) { 4579 return _ERC20Burnable.Contract.BalanceOf(&_ERC20Burnable.CallOpts, account) 4580 } 4581 4582 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 4583 // 4584 // Solidity: function balanceOf(address account) constant returns(uint256) 4585 func (_ERC20Burnable *ERC20BurnableCallerSession) BalanceOf(account common.Address) (*big.Int, error) { 4586 return _ERC20Burnable.Contract.BalanceOf(&_ERC20Burnable.CallOpts, account) 4587 } 4588 4589 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 4590 // 4591 // Solidity: function totalSupply() constant returns(uint256) 4592 func (_ERC20Burnable *ERC20BurnableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 4593 var ( 4594 ret0 = new(*big.Int) 4595 ) 4596 out := ret0 4597 err := _ERC20Burnable.contract.Call(opts, out, "totalSupply") 4598 return *ret0, err 4599 } 4600 4601 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 4602 // 4603 // Solidity: function totalSupply() constant returns(uint256) 4604 func (_ERC20Burnable *ERC20BurnableSession) TotalSupply() (*big.Int, error) { 4605 return _ERC20Burnable.Contract.TotalSupply(&_ERC20Burnable.CallOpts) 4606 } 4607 4608 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 4609 // 4610 // Solidity: function totalSupply() constant returns(uint256) 4611 func (_ERC20Burnable *ERC20BurnableCallerSession) TotalSupply() (*big.Int, error) { 4612 return _ERC20Burnable.Contract.TotalSupply(&_ERC20Burnable.CallOpts) 4613 } 4614 4615 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 4616 // 4617 // Solidity: function approve(address spender, uint256 amount) returns(bool) 4618 func (_ERC20Burnable *ERC20BurnableTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 4619 return _ERC20Burnable.contract.Transact(opts, "approve", spender, amount) 4620 } 4621 4622 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 4623 // 4624 // Solidity: function approve(address spender, uint256 amount) returns(bool) 4625 func (_ERC20Burnable *ERC20BurnableSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 4626 return _ERC20Burnable.Contract.Approve(&_ERC20Burnable.TransactOpts, spender, amount) 4627 } 4628 4629 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 4630 // 4631 // Solidity: function approve(address spender, uint256 amount) returns(bool) 4632 func (_ERC20Burnable *ERC20BurnableTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 4633 return _ERC20Burnable.Contract.Approve(&_ERC20Burnable.TransactOpts, spender, amount) 4634 } 4635 4636 // Burn is a paid mutator transaction binding the contract method 0x42966c68. 4637 // 4638 // Solidity: function burn(uint256 amount) returns() 4639 func (_ERC20Burnable *ERC20BurnableTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { 4640 return _ERC20Burnable.contract.Transact(opts, "burn", amount) 4641 } 4642 4643 // Burn is a paid mutator transaction binding the contract method 0x42966c68. 4644 // 4645 // Solidity: function burn(uint256 amount) returns() 4646 func (_ERC20Burnable *ERC20BurnableSession) Burn(amount *big.Int) (*types.Transaction, error) { 4647 return _ERC20Burnable.Contract.Burn(&_ERC20Burnable.TransactOpts, amount) 4648 } 4649 4650 // Burn is a paid mutator transaction binding the contract method 0x42966c68. 4651 // 4652 // Solidity: function burn(uint256 amount) returns() 4653 func (_ERC20Burnable *ERC20BurnableTransactorSession) Burn(amount *big.Int) (*types.Transaction, error) { 4654 return _ERC20Burnable.Contract.Burn(&_ERC20Burnable.TransactOpts, amount) 4655 } 4656 4657 // BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790. 4658 // 4659 // Solidity: function burnFrom(address account, uint256 amount) returns() 4660 func (_ERC20Burnable *ERC20BurnableTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { 4661 return _ERC20Burnable.contract.Transact(opts, "burnFrom", account, amount) 4662 } 4663 4664 // BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790. 4665 // 4666 // Solidity: function burnFrom(address account, uint256 amount) returns() 4667 func (_ERC20Burnable *ERC20BurnableSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) { 4668 return _ERC20Burnable.Contract.BurnFrom(&_ERC20Burnable.TransactOpts, account, amount) 4669 } 4670 4671 // BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790. 4672 // 4673 // Solidity: function burnFrom(address account, uint256 amount) returns() 4674 func (_ERC20Burnable *ERC20BurnableTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) { 4675 return _ERC20Burnable.Contract.BurnFrom(&_ERC20Burnable.TransactOpts, account, amount) 4676 } 4677 4678 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 4679 // 4680 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 4681 func (_ERC20Burnable *ERC20BurnableTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 4682 return _ERC20Burnable.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) 4683 } 4684 4685 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 4686 // 4687 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 4688 func (_ERC20Burnable *ERC20BurnableSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 4689 return _ERC20Burnable.Contract.DecreaseAllowance(&_ERC20Burnable.TransactOpts, spender, subtractedValue) 4690 } 4691 4692 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 4693 // 4694 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 4695 func (_ERC20Burnable *ERC20BurnableTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 4696 return _ERC20Burnable.Contract.DecreaseAllowance(&_ERC20Burnable.TransactOpts, spender, subtractedValue) 4697 } 4698 4699 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 4700 // 4701 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 4702 func (_ERC20Burnable *ERC20BurnableTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 4703 return _ERC20Burnable.contract.Transact(opts, "increaseAllowance", spender, addedValue) 4704 } 4705 4706 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 4707 // 4708 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 4709 func (_ERC20Burnable *ERC20BurnableSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 4710 return _ERC20Burnable.Contract.IncreaseAllowance(&_ERC20Burnable.TransactOpts, spender, addedValue) 4711 } 4712 4713 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 4714 // 4715 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 4716 func (_ERC20Burnable *ERC20BurnableTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 4717 return _ERC20Burnable.Contract.IncreaseAllowance(&_ERC20Burnable.TransactOpts, spender, addedValue) 4718 } 4719 4720 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 4721 // 4722 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 4723 func (_ERC20Burnable *ERC20BurnableTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4724 return _ERC20Burnable.contract.Transact(opts, "transfer", recipient, amount) 4725 } 4726 4727 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 4728 // 4729 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 4730 func (_ERC20Burnable *ERC20BurnableSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4731 return _ERC20Burnable.Contract.Transfer(&_ERC20Burnable.TransactOpts, recipient, amount) 4732 } 4733 4734 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 4735 // 4736 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 4737 func (_ERC20Burnable *ERC20BurnableTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4738 return _ERC20Burnable.Contract.Transfer(&_ERC20Burnable.TransactOpts, recipient, amount) 4739 } 4740 4741 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 4742 // 4743 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 4744 func (_ERC20Burnable *ERC20BurnableTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4745 return _ERC20Burnable.contract.Transact(opts, "transferFrom", sender, recipient, amount) 4746 } 4747 4748 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 4749 // 4750 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 4751 func (_ERC20Burnable *ERC20BurnableSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4752 return _ERC20Burnable.Contract.TransferFrom(&_ERC20Burnable.TransactOpts, sender, recipient, amount) 4753 } 4754 4755 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 4756 // 4757 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 4758 func (_ERC20Burnable *ERC20BurnableTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4759 return _ERC20Burnable.Contract.TransferFrom(&_ERC20Burnable.TransactOpts, sender, recipient, amount) 4760 } 4761 4762 // ERC20BurnableApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20Burnable contract. 4763 type ERC20BurnableApprovalIterator struct { 4764 Event *ERC20BurnableApproval // Event containing the contract specifics and raw log 4765 4766 contract *bind.BoundContract // Generic contract to use for unpacking event data 4767 event string // Event name to use for unpacking event data 4768 4769 logs chan types.Log // Log channel receiving the found contract events 4770 sub ethereum.Subscription // Subscription for errors, completion and termination 4771 done bool // Whether the subscription completed delivering logs 4772 fail error // Occurred error to stop iteration 4773 } 4774 4775 // Next advances the iterator to the subsequent event, returning whether there 4776 // are any more events found. In case of a retrieval or parsing error, false is 4777 // returned and Error() can be queried for the exact failure. 4778 func (it *ERC20BurnableApprovalIterator) Next() bool { 4779 // If the iterator failed, stop iterating 4780 if it.fail != nil { 4781 return false 4782 } 4783 // If the iterator completed, deliver directly whatever's available 4784 if it.done { 4785 select { 4786 case log := <-it.logs: 4787 it.Event = new(ERC20BurnableApproval) 4788 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4789 it.fail = err 4790 return false 4791 } 4792 it.Event.Raw = log 4793 return true 4794 4795 default: 4796 return false 4797 } 4798 } 4799 // Iterator still in progress, wait for either a data or an error event 4800 select { 4801 case log := <-it.logs: 4802 it.Event = new(ERC20BurnableApproval) 4803 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4804 it.fail = err 4805 return false 4806 } 4807 it.Event.Raw = log 4808 return true 4809 4810 case err := <-it.sub.Err(): 4811 it.done = true 4812 it.fail = err 4813 return it.Next() 4814 } 4815 } 4816 4817 // Error returns any retrieval or parsing error occurred during filtering. 4818 func (it *ERC20BurnableApprovalIterator) Error() error { 4819 return it.fail 4820 } 4821 4822 // Close terminates the iteration process, releasing any pending underlying 4823 // resources. 4824 func (it *ERC20BurnableApprovalIterator) Close() error { 4825 it.sub.Unsubscribe() 4826 return nil 4827 } 4828 4829 // ERC20BurnableApproval represents a Approval event raised by the ERC20Burnable contract. 4830 type ERC20BurnableApproval struct { 4831 Owner common.Address 4832 Spender common.Address 4833 Value *big.Int 4834 Raw types.Log // Blockchain specific contextual infos 4835 } 4836 4837 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 4838 // 4839 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 4840 func (_ERC20Burnable *ERC20BurnableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20BurnableApprovalIterator, error) { 4841 4842 var ownerRule []interface{} 4843 for _, ownerItem := range owner { 4844 ownerRule = append(ownerRule, ownerItem) 4845 } 4846 var spenderRule []interface{} 4847 for _, spenderItem := range spender { 4848 spenderRule = append(spenderRule, spenderItem) 4849 } 4850 4851 logs, sub, err := _ERC20Burnable.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 4852 if err != nil { 4853 return nil, err 4854 } 4855 return &ERC20BurnableApprovalIterator{contract: _ERC20Burnable.contract, event: "Approval", logs: logs, sub: sub}, nil 4856 } 4857 4858 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 4859 // 4860 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 4861 func (_ERC20Burnable *ERC20BurnableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20BurnableApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 4862 4863 var ownerRule []interface{} 4864 for _, ownerItem := range owner { 4865 ownerRule = append(ownerRule, ownerItem) 4866 } 4867 var spenderRule []interface{} 4868 for _, spenderItem := range spender { 4869 spenderRule = append(spenderRule, spenderItem) 4870 } 4871 4872 logs, sub, err := _ERC20Burnable.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 4873 if err != nil { 4874 return nil, err 4875 } 4876 return event.NewSubscription(func(quit <-chan struct{}) error { 4877 defer sub.Unsubscribe() 4878 for { 4879 select { 4880 case log := <-logs: 4881 // New log arrived, parse the event and forward to the user 4882 event := new(ERC20BurnableApproval) 4883 if err := _ERC20Burnable.contract.UnpackLog(event, "Approval", log); err != nil { 4884 return err 4885 } 4886 event.Raw = log 4887 4888 select { 4889 case sink <- event: 4890 case err := <-sub.Err(): 4891 return err 4892 case <-quit: 4893 return nil 4894 } 4895 case err := <-sub.Err(): 4896 return err 4897 case <-quit: 4898 return nil 4899 } 4900 } 4901 }), nil 4902 } 4903 4904 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 4905 // 4906 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 4907 func (_ERC20Burnable *ERC20BurnableFilterer) ParseApproval(log types.Log) (*ERC20BurnableApproval, error) { 4908 event := new(ERC20BurnableApproval) 4909 if err := _ERC20Burnable.contract.UnpackLog(event, "Approval", log); err != nil { 4910 return nil, err 4911 } 4912 return event, nil 4913 } 4914 4915 // ERC20BurnableTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20Burnable contract. 4916 type ERC20BurnableTransferIterator struct { 4917 Event *ERC20BurnableTransfer // Event containing the contract specifics and raw log 4918 4919 contract *bind.BoundContract // Generic contract to use for unpacking event data 4920 event string // Event name to use for unpacking event data 4921 4922 logs chan types.Log // Log channel receiving the found contract events 4923 sub ethereum.Subscription // Subscription for errors, completion and termination 4924 done bool // Whether the subscription completed delivering logs 4925 fail error // Occurred error to stop iteration 4926 } 4927 4928 // Next advances the iterator to the subsequent event, returning whether there 4929 // are any more events found. In case of a retrieval or parsing error, false is 4930 // returned and Error() can be queried for the exact failure. 4931 func (it *ERC20BurnableTransferIterator) Next() bool { 4932 // If the iterator failed, stop iterating 4933 if it.fail != nil { 4934 return false 4935 } 4936 // If the iterator completed, deliver directly whatever's available 4937 if it.done { 4938 select { 4939 case log := <-it.logs: 4940 it.Event = new(ERC20BurnableTransfer) 4941 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4942 it.fail = err 4943 return false 4944 } 4945 it.Event.Raw = log 4946 return true 4947 4948 default: 4949 return false 4950 } 4951 } 4952 // Iterator still in progress, wait for either a data or an error event 4953 select { 4954 case log := <-it.logs: 4955 it.Event = new(ERC20BurnableTransfer) 4956 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4957 it.fail = err 4958 return false 4959 } 4960 it.Event.Raw = log 4961 return true 4962 4963 case err := <-it.sub.Err(): 4964 it.done = true 4965 it.fail = err 4966 return it.Next() 4967 } 4968 } 4969 4970 // Error returns any retrieval or parsing error occurred during filtering. 4971 func (it *ERC20BurnableTransferIterator) Error() error { 4972 return it.fail 4973 } 4974 4975 // Close terminates the iteration process, releasing any pending underlying 4976 // resources. 4977 func (it *ERC20BurnableTransferIterator) Close() error { 4978 it.sub.Unsubscribe() 4979 return nil 4980 } 4981 4982 // ERC20BurnableTransfer represents a Transfer event raised by the ERC20Burnable contract. 4983 type ERC20BurnableTransfer struct { 4984 From common.Address 4985 To common.Address 4986 Value *big.Int 4987 Raw types.Log // Blockchain specific contextual infos 4988 } 4989 4990 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 4991 // 4992 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 4993 func (_ERC20Burnable *ERC20BurnableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20BurnableTransferIterator, error) { 4994 4995 var fromRule []interface{} 4996 for _, fromItem := range from { 4997 fromRule = append(fromRule, fromItem) 4998 } 4999 var toRule []interface{} 5000 for _, toItem := range to { 5001 toRule = append(toRule, toItem) 5002 } 5003 5004 logs, sub, err := _ERC20Burnable.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 5005 if err != nil { 5006 return nil, err 5007 } 5008 return &ERC20BurnableTransferIterator{contract: _ERC20Burnable.contract, event: "Transfer", logs: logs, sub: sub}, nil 5009 } 5010 5011 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 5012 // 5013 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 5014 func (_ERC20Burnable *ERC20BurnableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20BurnableTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 5015 5016 var fromRule []interface{} 5017 for _, fromItem := range from { 5018 fromRule = append(fromRule, fromItem) 5019 } 5020 var toRule []interface{} 5021 for _, toItem := range to { 5022 toRule = append(toRule, toItem) 5023 } 5024 5025 logs, sub, err := _ERC20Burnable.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 5026 if err != nil { 5027 return nil, err 5028 } 5029 return event.NewSubscription(func(quit <-chan struct{}) error { 5030 defer sub.Unsubscribe() 5031 for { 5032 select { 5033 case log := <-logs: 5034 // New log arrived, parse the event and forward to the user 5035 event := new(ERC20BurnableTransfer) 5036 if err := _ERC20Burnable.contract.UnpackLog(event, "Transfer", log); err != nil { 5037 return err 5038 } 5039 event.Raw = log 5040 5041 select { 5042 case sink <- event: 5043 case err := <-sub.Err(): 5044 return err 5045 case <-quit: 5046 return nil 5047 } 5048 case err := <-sub.Err(): 5049 return err 5050 case <-quit: 5051 return nil 5052 } 5053 } 5054 }), nil 5055 } 5056 5057 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 5058 // 5059 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 5060 func (_ERC20Burnable *ERC20BurnableFilterer) ParseTransfer(log types.Log) (*ERC20BurnableTransfer, error) { 5061 event := new(ERC20BurnableTransfer) 5062 if err := _ERC20Burnable.contract.UnpackLog(event, "Transfer", log); err != nil { 5063 return nil, err 5064 } 5065 return event, nil 5066 } 5067 5068 // ERC20DetailedABI is the input ABI used to generate the binding from. 5069 const ERC20DetailedABI = "[{\"inputs\":[{\"internalType\":\"string\",\"name\":\"name\",\"type\":\"string\"},{\"internalType\":\"string\",\"name\":\"symbol\",\"type\":\"string\"},{\"internalType\":\"uint8\",\"name\":\"decimals\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"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\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 5070 5071 // ERC20DetailedFuncSigs maps the 4-byte function signature to its string representation. 5072 var ERC20DetailedFuncSigs = map[string]string{ 5073 "dd62ed3e": "allowance(address,address)", 5074 "095ea7b3": "approve(address,uint256)", 5075 "70a08231": "balanceOf(address)", 5076 "313ce567": "decimals()", 5077 "06fdde03": "name()", 5078 "95d89b41": "symbol()", 5079 "18160ddd": "totalSupply()", 5080 "a9059cbb": "transfer(address,uint256)", 5081 "23b872dd": "transferFrom(address,address,uint256)", 5082 } 5083 5084 // ERC20Detailed is an auto generated Go binding around an Ethereum contract. 5085 type ERC20Detailed struct { 5086 ERC20DetailedCaller // Read-only binding to the contract 5087 ERC20DetailedTransactor // Write-only binding to the contract 5088 ERC20DetailedFilterer // Log filterer for contract events 5089 } 5090 5091 // ERC20DetailedCaller is an auto generated read-only Go binding around an Ethereum contract. 5092 type ERC20DetailedCaller struct { 5093 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5094 } 5095 5096 // ERC20DetailedTransactor is an auto generated write-only Go binding around an Ethereum contract. 5097 type ERC20DetailedTransactor struct { 5098 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5099 } 5100 5101 // ERC20DetailedFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 5102 type ERC20DetailedFilterer struct { 5103 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5104 } 5105 5106 // ERC20DetailedSession is an auto generated Go binding around an Ethereum contract, 5107 // with pre-set call and transact options. 5108 type ERC20DetailedSession struct { 5109 Contract *ERC20Detailed // Generic contract binding to set the session for 5110 CallOpts bind.CallOpts // Call options to use throughout this session 5111 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 5112 } 5113 5114 // ERC20DetailedCallerSession is an auto generated read-only Go binding around an Ethereum contract, 5115 // with pre-set call options. 5116 type ERC20DetailedCallerSession struct { 5117 Contract *ERC20DetailedCaller // Generic contract caller binding to set the session for 5118 CallOpts bind.CallOpts // Call options to use throughout this session 5119 } 5120 5121 // ERC20DetailedTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 5122 // with pre-set transact options. 5123 type ERC20DetailedTransactorSession struct { 5124 Contract *ERC20DetailedTransactor // Generic contract transactor binding to set the session for 5125 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 5126 } 5127 5128 // ERC20DetailedRaw is an auto generated low-level Go binding around an Ethereum contract. 5129 type ERC20DetailedRaw struct { 5130 Contract *ERC20Detailed // Generic contract binding to access the raw methods on 5131 } 5132 5133 // ERC20DetailedCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 5134 type ERC20DetailedCallerRaw struct { 5135 Contract *ERC20DetailedCaller // Generic read-only contract binding to access the raw methods on 5136 } 5137 5138 // ERC20DetailedTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 5139 type ERC20DetailedTransactorRaw struct { 5140 Contract *ERC20DetailedTransactor // Generic write-only contract binding to access the raw methods on 5141 } 5142 5143 // NewERC20Detailed creates a new instance of ERC20Detailed, bound to a specific deployed contract. 5144 func NewERC20Detailed(address common.Address, backend bind.ContractBackend) (*ERC20Detailed, error) { 5145 contract, err := bindERC20Detailed(address, backend, backend, backend) 5146 if err != nil { 5147 return nil, err 5148 } 5149 return &ERC20Detailed{ERC20DetailedCaller: ERC20DetailedCaller{contract: contract}, ERC20DetailedTransactor: ERC20DetailedTransactor{contract: contract}, ERC20DetailedFilterer: ERC20DetailedFilterer{contract: contract}}, nil 5150 } 5151 5152 // NewERC20DetailedCaller creates a new read-only instance of ERC20Detailed, bound to a specific deployed contract. 5153 func NewERC20DetailedCaller(address common.Address, caller bind.ContractCaller) (*ERC20DetailedCaller, error) { 5154 contract, err := bindERC20Detailed(address, caller, nil, nil) 5155 if err != nil { 5156 return nil, err 5157 } 5158 return &ERC20DetailedCaller{contract: contract}, nil 5159 } 5160 5161 // NewERC20DetailedTransactor creates a new write-only instance of ERC20Detailed, bound to a specific deployed contract. 5162 func NewERC20DetailedTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20DetailedTransactor, error) { 5163 contract, err := bindERC20Detailed(address, nil, transactor, nil) 5164 if err != nil { 5165 return nil, err 5166 } 5167 return &ERC20DetailedTransactor{contract: contract}, nil 5168 } 5169 5170 // NewERC20DetailedFilterer creates a new log filterer instance of ERC20Detailed, bound to a specific deployed contract. 5171 func NewERC20DetailedFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20DetailedFilterer, error) { 5172 contract, err := bindERC20Detailed(address, nil, nil, filterer) 5173 if err != nil { 5174 return nil, err 5175 } 5176 return &ERC20DetailedFilterer{contract: contract}, nil 5177 } 5178 5179 // bindERC20Detailed binds a generic wrapper to an already deployed contract. 5180 func bindERC20Detailed(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 5181 parsed, err := abi.JSON(strings.NewReader(ERC20DetailedABI)) 5182 if err != nil { 5183 return nil, err 5184 } 5185 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 5186 } 5187 5188 // Call invokes the (constant) contract method with params as input values and 5189 // sets the output to result. The result type might be a single field for simple 5190 // returns, a slice of interfaces for anonymous returns and a struct for named 5191 // returns. 5192 func (_ERC20Detailed *ERC20DetailedRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 5193 return _ERC20Detailed.Contract.ERC20DetailedCaller.contract.Call(opts, result, method, params...) 5194 } 5195 5196 // Transfer initiates a plain transaction to move funds to the contract, calling 5197 // its default method if one is available. 5198 func (_ERC20Detailed *ERC20DetailedRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 5199 return _ERC20Detailed.Contract.ERC20DetailedTransactor.contract.Transfer(opts) 5200 } 5201 5202 // Transact invokes the (paid) contract method with params as input values. 5203 func (_ERC20Detailed *ERC20DetailedRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 5204 return _ERC20Detailed.Contract.ERC20DetailedTransactor.contract.Transact(opts, method, params...) 5205 } 5206 5207 // Call invokes the (constant) contract method with params as input values and 5208 // sets the output to result. The result type might be a single field for simple 5209 // returns, a slice of interfaces for anonymous returns and a struct for named 5210 // returns. 5211 func (_ERC20Detailed *ERC20DetailedCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 5212 return _ERC20Detailed.Contract.contract.Call(opts, result, method, params...) 5213 } 5214 5215 // Transfer initiates a plain transaction to move funds to the contract, calling 5216 // its default method if one is available. 5217 func (_ERC20Detailed *ERC20DetailedTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 5218 return _ERC20Detailed.Contract.contract.Transfer(opts) 5219 } 5220 5221 // Transact invokes the (paid) contract method with params as input values. 5222 func (_ERC20Detailed *ERC20DetailedTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 5223 return _ERC20Detailed.Contract.contract.Transact(opts, method, params...) 5224 } 5225 5226 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 5227 // 5228 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 5229 func (_ERC20Detailed *ERC20DetailedCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 5230 var ( 5231 ret0 = new(*big.Int) 5232 ) 5233 out := ret0 5234 err := _ERC20Detailed.contract.Call(opts, out, "allowance", owner, spender) 5235 return *ret0, err 5236 } 5237 5238 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 5239 // 5240 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 5241 func (_ERC20Detailed *ERC20DetailedSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 5242 return _ERC20Detailed.Contract.Allowance(&_ERC20Detailed.CallOpts, owner, spender) 5243 } 5244 5245 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 5246 // 5247 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 5248 func (_ERC20Detailed *ERC20DetailedCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 5249 return _ERC20Detailed.Contract.Allowance(&_ERC20Detailed.CallOpts, owner, spender) 5250 } 5251 5252 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 5253 // 5254 // Solidity: function balanceOf(address account) constant returns(uint256) 5255 func (_ERC20Detailed *ERC20DetailedCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 5256 var ( 5257 ret0 = new(*big.Int) 5258 ) 5259 out := ret0 5260 err := _ERC20Detailed.contract.Call(opts, out, "balanceOf", account) 5261 return *ret0, err 5262 } 5263 5264 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 5265 // 5266 // Solidity: function balanceOf(address account) constant returns(uint256) 5267 func (_ERC20Detailed *ERC20DetailedSession) BalanceOf(account common.Address) (*big.Int, error) { 5268 return _ERC20Detailed.Contract.BalanceOf(&_ERC20Detailed.CallOpts, account) 5269 } 5270 5271 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 5272 // 5273 // Solidity: function balanceOf(address account) constant returns(uint256) 5274 func (_ERC20Detailed *ERC20DetailedCallerSession) BalanceOf(account common.Address) (*big.Int, error) { 5275 return _ERC20Detailed.Contract.BalanceOf(&_ERC20Detailed.CallOpts, account) 5276 } 5277 5278 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 5279 // 5280 // Solidity: function decimals() constant returns(uint8) 5281 func (_ERC20Detailed *ERC20DetailedCaller) Decimals(opts *bind.CallOpts) (uint8, error) { 5282 var ( 5283 ret0 = new(uint8) 5284 ) 5285 out := ret0 5286 err := _ERC20Detailed.contract.Call(opts, out, "decimals") 5287 return *ret0, err 5288 } 5289 5290 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 5291 // 5292 // Solidity: function decimals() constant returns(uint8) 5293 func (_ERC20Detailed *ERC20DetailedSession) Decimals() (uint8, error) { 5294 return _ERC20Detailed.Contract.Decimals(&_ERC20Detailed.CallOpts) 5295 } 5296 5297 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 5298 // 5299 // Solidity: function decimals() constant returns(uint8) 5300 func (_ERC20Detailed *ERC20DetailedCallerSession) Decimals() (uint8, error) { 5301 return _ERC20Detailed.Contract.Decimals(&_ERC20Detailed.CallOpts) 5302 } 5303 5304 // Name is a free data retrieval call binding the contract method 0x06fdde03. 5305 // 5306 // Solidity: function name() constant returns(string) 5307 func (_ERC20Detailed *ERC20DetailedCaller) Name(opts *bind.CallOpts) (string, error) { 5308 var ( 5309 ret0 = new(string) 5310 ) 5311 out := ret0 5312 err := _ERC20Detailed.contract.Call(opts, out, "name") 5313 return *ret0, err 5314 } 5315 5316 // Name is a free data retrieval call binding the contract method 0x06fdde03. 5317 // 5318 // Solidity: function name() constant returns(string) 5319 func (_ERC20Detailed *ERC20DetailedSession) Name() (string, error) { 5320 return _ERC20Detailed.Contract.Name(&_ERC20Detailed.CallOpts) 5321 } 5322 5323 // Name is a free data retrieval call binding the contract method 0x06fdde03. 5324 // 5325 // Solidity: function name() constant returns(string) 5326 func (_ERC20Detailed *ERC20DetailedCallerSession) Name() (string, error) { 5327 return _ERC20Detailed.Contract.Name(&_ERC20Detailed.CallOpts) 5328 } 5329 5330 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 5331 // 5332 // Solidity: function symbol() constant returns(string) 5333 func (_ERC20Detailed *ERC20DetailedCaller) Symbol(opts *bind.CallOpts) (string, error) { 5334 var ( 5335 ret0 = new(string) 5336 ) 5337 out := ret0 5338 err := _ERC20Detailed.contract.Call(opts, out, "symbol") 5339 return *ret0, err 5340 } 5341 5342 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 5343 // 5344 // Solidity: function symbol() constant returns(string) 5345 func (_ERC20Detailed *ERC20DetailedSession) Symbol() (string, error) { 5346 return _ERC20Detailed.Contract.Symbol(&_ERC20Detailed.CallOpts) 5347 } 5348 5349 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 5350 // 5351 // Solidity: function symbol() constant returns(string) 5352 func (_ERC20Detailed *ERC20DetailedCallerSession) Symbol() (string, error) { 5353 return _ERC20Detailed.Contract.Symbol(&_ERC20Detailed.CallOpts) 5354 } 5355 5356 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 5357 // 5358 // Solidity: function totalSupply() constant returns(uint256) 5359 func (_ERC20Detailed *ERC20DetailedCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 5360 var ( 5361 ret0 = new(*big.Int) 5362 ) 5363 out := ret0 5364 err := _ERC20Detailed.contract.Call(opts, out, "totalSupply") 5365 return *ret0, err 5366 } 5367 5368 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 5369 // 5370 // Solidity: function totalSupply() constant returns(uint256) 5371 func (_ERC20Detailed *ERC20DetailedSession) TotalSupply() (*big.Int, error) { 5372 return _ERC20Detailed.Contract.TotalSupply(&_ERC20Detailed.CallOpts) 5373 } 5374 5375 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 5376 // 5377 // Solidity: function totalSupply() constant returns(uint256) 5378 func (_ERC20Detailed *ERC20DetailedCallerSession) TotalSupply() (*big.Int, error) { 5379 return _ERC20Detailed.Contract.TotalSupply(&_ERC20Detailed.CallOpts) 5380 } 5381 5382 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 5383 // 5384 // Solidity: function approve(address spender, uint256 amount) returns(bool) 5385 func (_ERC20Detailed *ERC20DetailedTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 5386 return _ERC20Detailed.contract.Transact(opts, "approve", spender, amount) 5387 } 5388 5389 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 5390 // 5391 // Solidity: function approve(address spender, uint256 amount) returns(bool) 5392 func (_ERC20Detailed *ERC20DetailedSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 5393 return _ERC20Detailed.Contract.Approve(&_ERC20Detailed.TransactOpts, spender, amount) 5394 } 5395 5396 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 5397 // 5398 // Solidity: function approve(address spender, uint256 amount) returns(bool) 5399 func (_ERC20Detailed *ERC20DetailedTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 5400 return _ERC20Detailed.Contract.Approve(&_ERC20Detailed.TransactOpts, spender, amount) 5401 } 5402 5403 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 5404 // 5405 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 5406 func (_ERC20Detailed *ERC20DetailedTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 5407 return _ERC20Detailed.contract.Transact(opts, "transfer", recipient, amount) 5408 } 5409 5410 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 5411 // 5412 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 5413 func (_ERC20Detailed *ERC20DetailedSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 5414 return _ERC20Detailed.Contract.Transfer(&_ERC20Detailed.TransactOpts, recipient, amount) 5415 } 5416 5417 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 5418 // 5419 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 5420 func (_ERC20Detailed *ERC20DetailedTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 5421 return _ERC20Detailed.Contract.Transfer(&_ERC20Detailed.TransactOpts, recipient, amount) 5422 } 5423 5424 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 5425 // 5426 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 5427 func (_ERC20Detailed *ERC20DetailedTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 5428 return _ERC20Detailed.contract.Transact(opts, "transferFrom", sender, recipient, amount) 5429 } 5430 5431 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 5432 // 5433 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 5434 func (_ERC20Detailed *ERC20DetailedSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 5435 return _ERC20Detailed.Contract.TransferFrom(&_ERC20Detailed.TransactOpts, sender, recipient, amount) 5436 } 5437 5438 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 5439 // 5440 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 5441 func (_ERC20Detailed *ERC20DetailedTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 5442 return _ERC20Detailed.Contract.TransferFrom(&_ERC20Detailed.TransactOpts, sender, recipient, amount) 5443 } 5444 5445 // ERC20DetailedApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20Detailed contract. 5446 type ERC20DetailedApprovalIterator struct { 5447 Event *ERC20DetailedApproval // Event containing the contract specifics and raw log 5448 5449 contract *bind.BoundContract // Generic contract to use for unpacking event data 5450 event string // Event name to use for unpacking event data 5451 5452 logs chan types.Log // Log channel receiving the found contract events 5453 sub ethereum.Subscription // Subscription for errors, completion and termination 5454 done bool // Whether the subscription completed delivering logs 5455 fail error // Occurred error to stop iteration 5456 } 5457 5458 // Next advances the iterator to the subsequent event, returning whether there 5459 // are any more events found. In case of a retrieval or parsing error, false is 5460 // returned and Error() can be queried for the exact failure. 5461 func (it *ERC20DetailedApprovalIterator) Next() bool { 5462 // If the iterator failed, stop iterating 5463 if it.fail != nil { 5464 return false 5465 } 5466 // If the iterator completed, deliver directly whatever's available 5467 if it.done { 5468 select { 5469 case log := <-it.logs: 5470 it.Event = new(ERC20DetailedApproval) 5471 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 5472 it.fail = err 5473 return false 5474 } 5475 it.Event.Raw = log 5476 return true 5477 5478 default: 5479 return false 5480 } 5481 } 5482 // Iterator still in progress, wait for either a data or an error event 5483 select { 5484 case log := <-it.logs: 5485 it.Event = new(ERC20DetailedApproval) 5486 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 5487 it.fail = err 5488 return false 5489 } 5490 it.Event.Raw = log 5491 return true 5492 5493 case err := <-it.sub.Err(): 5494 it.done = true 5495 it.fail = err 5496 return it.Next() 5497 } 5498 } 5499 5500 // Error returns any retrieval or parsing error occurred during filtering. 5501 func (it *ERC20DetailedApprovalIterator) Error() error { 5502 return it.fail 5503 } 5504 5505 // Close terminates the iteration process, releasing any pending underlying 5506 // resources. 5507 func (it *ERC20DetailedApprovalIterator) Close() error { 5508 it.sub.Unsubscribe() 5509 return nil 5510 } 5511 5512 // ERC20DetailedApproval represents a Approval event raised by the ERC20Detailed contract. 5513 type ERC20DetailedApproval struct { 5514 Owner common.Address 5515 Spender common.Address 5516 Value *big.Int 5517 Raw types.Log // Blockchain specific contextual infos 5518 } 5519 5520 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 5521 // 5522 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 5523 func (_ERC20Detailed *ERC20DetailedFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20DetailedApprovalIterator, error) { 5524 5525 var ownerRule []interface{} 5526 for _, ownerItem := range owner { 5527 ownerRule = append(ownerRule, ownerItem) 5528 } 5529 var spenderRule []interface{} 5530 for _, spenderItem := range spender { 5531 spenderRule = append(spenderRule, spenderItem) 5532 } 5533 5534 logs, sub, err := _ERC20Detailed.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 5535 if err != nil { 5536 return nil, err 5537 } 5538 return &ERC20DetailedApprovalIterator{contract: _ERC20Detailed.contract, event: "Approval", logs: logs, sub: sub}, nil 5539 } 5540 5541 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 5542 // 5543 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 5544 func (_ERC20Detailed *ERC20DetailedFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20DetailedApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 5545 5546 var ownerRule []interface{} 5547 for _, ownerItem := range owner { 5548 ownerRule = append(ownerRule, ownerItem) 5549 } 5550 var spenderRule []interface{} 5551 for _, spenderItem := range spender { 5552 spenderRule = append(spenderRule, spenderItem) 5553 } 5554 5555 logs, sub, err := _ERC20Detailed.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 5556 if err != nil { 5557 return nil, err 5558 } 5559 return event.NewSubscription(func(quit <-chan struct{}) error { 5560 defer sub.Unsubscribe() 5561 for { 5562 select { 5563 case log := <-logs: 5564 // New log arrived, parse the event and forward to the user 5565 event := new(ERC20DetailedApproval) 5566 if err := _ERC20Detailed.contract.UnpackLog(event, "Approval", log); err != nil { 5567 return err 5568 } 5569 event.Raw = log 5570 5571 select { 5572 case sink <- event: 5573 case err := <-sub.Err(): 5574 return err 5575 case <-quit: 5576 return nil 5577 } 5578 case err := <-sub.Err(): 5579 return err 5580 case <-quit: 5581 return nil 5582 } 5583 } 5584 }), nil 5585 } 5586 5587 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 5588 // 5589 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 5590 func (_ERC20Detailed *ERC20DetailedFilterer) ParseApproval(log types.Log) (*ERC20DetailedApproval, error) { 5591 event := new(ERC20DetailedApproval) 5592 if err := _ERC20Detailed.contract.UnpackLog(event, "Approval", log); err != nil { 5593 return nil, err 5594 } 5595 return event, nil 5596 } 5597 5598 // ERC20DetailedTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20Detailed contract. 5599 type ERC20DetailedTransferIterator struct { 5600 Event *ERC20DetailedTransfer // Event containing the contract specifics and raw log 5601 5602 contract *bind.BoundContract // Generic contract to use for unpacking event data 5603 event string // Event name to use for unpacking event data 5604 5605 logs chan types.Log // Log channel receiving the found contract events 5606 sub ethereum.Subscription // Subscription for errors, completion and termination 5607 done bool // Whether the subscription completed delivering logs 5608 fail error // Occurred error to stop iteration 5609 } 5610 5611 // Next advances the iterator to the subsequent event, returning whether there 5612 // are any more events found. In case of a retrieval or parsing error, false is 5613 // returned and Error() can be queried for the exact failure. 5614 func (it *ERC20DetailedTransferIterator) Next() bool { 5615 // If the iterator failed, stop iterating 5616 if it.fail != nil { 5617 return false 5618 } 5619 // If the iterator completed, deliver directly whatever's available 5620 if it.done { 5621 select { 5622 case log := <-it.logs: 5623 it.Event = new(ERC20DetailedTransfer) 5624 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 5625 it.fail = err 5626 return false 5627 } 5628 it.Event.Raw = log 5629 return true 5630 5631 default: 5632 return false 5633 } 5634 } 5635 // Iterator still in progress, wait for either a data or an error event 5636 select { 5637 case log := <-it.logs: 5638 it.Event = new(ERC20DetailedTransfer) 5639 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 5640 it.fail = err 5641 return false 5642 } 5643 it.Event.Raw = log 5644 return true 5645 5646 case err := <-it.sub.Err(): 5647 it.done = true 5648 it.fail = err 5649 return it.Next() 5650 } 5651 } 5652 5653 // Error returns any retrieval or parsing error occurred during filtering. 5654 func (it *ERC20DetailedTransferIterator) Error() error { 5655 return it.fail 5656 } 5657 5658 // Close terminates the iteration process, releasing any pending underlying 5659 // resources. 5660 func (it *ERC20DetailedTransferIterator) Close() error { 5661 it.sub.Unsubscribe() 5662 return nil 5663 } 5664 5665 // ERC20DetailedTransfer represents a Transfer event raised by the ERC20Detailed contract. 5666 type ERC20DetailedTransfer struct { 5667 From common.Address 5668 To common.Address 5669 Value *big.Int 5670 Raw types.Log // Blockchain specific contextual infos 5671 } 5672 5673 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 5674 // 5675 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 5676 func (_ERC20Detailed *ERC20DetailedFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20DetailedTransferIterator, error) { 5677 5678 var fromRule []interface{} 5679 for _, fromItem := range from { 5680 fromRule = append(fromRule, fromItem) 5681 } 5682 var toRule []interface{} 5683 for _, toItem := range to { 5684 toRule = append(toRule, toItem) 5685 } 5686 5687 logs, sub, err := _ERC20Detailed.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 5688 if err != nil { 5689 return nil, err 5690 } 5691 return &ERC20DetailedTransferIterator{contract: _ERC20Detailed.contract, event: "Transfer", logs: logs, sub: sub}, nil 5692 } 5693 5694 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 5695 // 5696 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 5697 func (_ERC20Detailed *ERC20DetailedFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20DetailedTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 5698 5699 var fromRule []interface{} 5700 for _, fromItem := range from { 5701 fromRule = append(fromRule, fromItem) 5702 } 5703 var toRule []interface{} 5704 for _, toItem := range to { 5705 toRule = append(toRule, toItem) 5706 } 5707 5708 logs, sub, err := _ERC20Detailed.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 5709 if err != nil { 5710 return nil, err 5711 } 5712 return event.NewSubscription(func(quit <-chan struct{}) error { 5713 defer sub.Unsubscribe() 5714 for { 5715 select { 5716 case log := <-logs: 5717 // New log arrived, parse the event and forward to the user 5718 event := new(ERC20DetailedTransfer) 5719 if err := _ERC20Detailed.contract.UnpackLog(event, "Transfer", log); err != nil { 5720 return err 5721 } 5722 event.Raw = log 5723 5724 select { 5725 case sink <- event: 5726 case err := <-sub.Err(): 5727 return err 5728 case <-quit: 5729 return nil 5730 } 5731 case err := <-sub.Err(): 5732 return err 5733 case <-quit: 5734 return nil 5735 } 5736 } 5737 }), nil 5738 } 5739 5740 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 5741 // 5742 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 5743 func (_ERC20Detailed *ERC20DetailedFilterer) ParseTransfer(log types.Log) (*ERC20DetailedTransfer, error) { 5744 event := new(ERC20DetailedTransfer) 5745 if err := _ERC20Detailed.contract.UnpackLog(event, "Transfer", log); err != nil { 5746 return nil, err 5747 } 5748 return event, nil 5749 } 5750 5751 // ERC20MintableABI is the input ABI used to generate the binding from. 5752 const ERC20MintableABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterRemoved\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isMinter\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"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\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 5753 5754 // ERC20MintableFuncSigs maps the 4-byte function signature to its string representation. 5755 var ERC20MintableFuncSigs = map[string]string{ 5756 "983b2d56": "addMinter(address)", 5757 "dd62ed3e": "allowance(address,address)", 5758 "095ea7b3": "approve(address,uint256)", 5759 "70a08231": "balanceOf(address)", 5760 "a457c2d7": "decreaseAllowance(address,uint256)", 5761 "39509351": "increaseAllowance(address,uint256)", 5762 "aa271e1a": "isMinter(address)", 5763 "40c10f19": "mint(address,uint256)", 5764 "98650275": "renounceMinter()", 5765 "18160ddd": "totalSupply()", 5766 "a9059cbb": "transfer(address,uint256)", 5767 "23b872dd": "transferFrom(address,address,uint256)", 5768 } 5769 5770 // ERC20MintableBin is the compiled bytecode used for deploying new contracts. 5771 var ERC20MintableBin = "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" 5772 5773 // DeployERC20Mintable deploys a new Ethereum contract, binding an instance of ERC20Mintable to it. 5774 func DeployERC20Mintable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20Mintable, error) { 5775 parsed, err := abi.JSON(strings.NewReader(ERC20MintableABI)) 5776 if err != nil { 5777 return common.Address{}, nil, nil, err 5778 } 5779 5780 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20MintableBin), backend) 5781 if err != nil { 5782 return common.Address{}, nil, nil, err 5783 } 5784 return address, tx, &ERC20Mintable{ERC20MintableCaller: ERC20MintableCaller{contract: contract}, ERC20MintableTransactor: ERC20MintableTransactor{contract: contract}, ERC20MintableFilterer: ERC20MintableFilterer{contract: contract}}, nil 5785 } 5786 5787 // ERC20Mintable is an auto generated Go binding around an Ethereum contract. 5788 type ERC20Mintable struct { 5789 ERC20MintableCaller // Read-only binding to the contract 5790 ERC20MintableTransactor // Write-only binding to the contract 5791 ERC20MintableFilterer // Log filterer for contract events 5792 } 5793 5794 // ERC20MintableCaller is an auto generated read-only Go binding around an Ethereum contract. 5795 type ERC20MintableCaller struct { 5796 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5797 } 5798 5799 // ERC20MintableTransactor is an auto generated write-only Go binding around an Ethereum contract. 5800 type ERC20MintableTransactor struct { 5801 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5802 } 5803 5804 // ERC20MintableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 5805 type ERC20MintableFilterer struct { 5806 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5807 } 5808 5809 // ERC20MintableSession is an auto generated Go binding around an Ethereum contract, 5810 // with pre-set call and transact options. 5811 type ERC20MintableSession struct { 5812 Contract *ERC20Mintable // Generic contract binding to set the session for 5813 CallOpts bind.CallOpts // Call options to use throughout this session 5814 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 5815 } 5816 5817 // ERC20MintableCallerSession is an auto generated read-only Go binding around an Ethereum contract, 5818 // with pre-set call options. 5819 type ERC20MintableCallerSession struct { 5820 Contract *ERC20MintableCaller // Generic contract caller binding to set the session for 5821 CallOpts bind.CallOpts // Call options to use throughout this session 5822 } 5823 5824 // ERC20MintableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 5825 // with pre-set transact options. 5826 type ERC20MintableTransactorSession struct { 5827 Contract *ERC20MintableTransactor // Generic contract transactor binding to set the session for 5828 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 5829 } 5830 5831 // ERC20MintableRaw is an auto generated low-level Go binding around an Ethereum contract. 5832 type ERC20MintableRaw struct { 5833 Contract *ERC20Mintable // Generic contract binding to access the raw methods on 5834 } 5835 5836 // ERC20MintableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 5837 type ERC20MintableCallerRaw struct { 5838 Contract *ERC20MintableCaller // Generic read-only contract binding to access the raw methods on 5839 } 5840 5841 // ERC20MintableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 5842 type ERC20MintableTransactorRaw struct { 5843 Contract *ERC20MintableTransactor // Generic write-only contract binding to access the raw methods on 5844 } 5845 5846 // NewERC20Mintable creates a new instance of ERC20Mintable, bound to a specific deployed contract. 5847 func NewERC20Mintable(address common.Address, backend bind.ContractBackend) (*ERC20Mintable, error) { 5848 contract, err := bindERC20Mintable(address, backend, backend, backend) 5849 if err != nil { 5850 return nil, err 5851 } 5852 return &ERC20Mintable{ERC20MintableCaller: ERC20MintableCaller{contract: contract}, ERC20MintableTransactor: ERC20MintableTransactor{contract: contract}, ERC20MintableFilterer: ERC20MintableFilterer{contract: contract}}, nil 5853 } 5854 5855 // NewERC20MintableCaller creates a new read-only instance of ERC20Mintable, bound to a specific deployed contract. 5856 func NewERC20MintableCaller(address common.Address, caller bind.ContractCaller) (*ERC20MintableCaller, error) { 5857 contract, err := bindERC20Mintable(address, caller, nil, nil) 5858 if err != nil { 5859 return nil, err 5860 } 5861 return &ERC20MintableCaller{contract: contract}, nil 5862 } 5863 5864 // NewERC20MintableTransactor creates a new write-only instance of ERC20Mintable, bound to a specific deployed contract. 5865 func NewERC20MintableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20MintableTransactor, error) { 5866 contract, err := bindERC20Mintable(address, nil, transactor, nil) 5867 if err != nil { 5868 return nil, err 5869 } 5870 return &ERC20MintableTransactor{contract: contract}, nil 5871 } 5872 5873 // NewERC20MintableFilterer creates a new log filterer instance of ERC20Mintable, bound to a specific deployed contract. 5874 func NewERC20MintableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20MintableFilterer, error) { 5875 contract, err := bindERC20Mintable(address, nil, nil, filterer) 5876 if err != nil { 5877 return nil, err 5878 } 5879 return &ERC20MintableFilterer{contract: contract}, nil 5880 } 5881 5882 // bindERC20Mintable binds a generic wrapper to an already deployed contract. 5883 func bindERC20Mintable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 5884 parsed, err := abi.JSON(strings.NewReader(ERC20MintableABI)) 5885 if err != nil { 5886 return nil, err 5887 } 5888 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 5889 } 5890 5891 // Call invokes the (constant) contract method with params as input values and 5892 // sets the output to result. The result type might be a single field for simple 5893 // returns, a slice of interfaces for anonymous returns and a struct for named 5894 // returns. 5895 func (_ERC20Mintable *ERC20MintableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 5896 return _ERC20Mintable.Contract.ERC20MintableCaller.contract.Call(opts, result, method, params...) 5897 } 5898 5899 // Transfer initiates a plain transaction to move funds to the contract, calling 5900 // its default method if one is available. 5901 func (_ERC20Mintable *ERC20MintableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 5902 return _ERC20Mintable.Contract.ERC20MintableTransactor.contract.Transfer(opts) 5903 } 5904 5905 // Transact invokes the (paid) contract method with params as input values. 5906 func (_ERC20Mintable *ERC20MintableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 5907 return _ERC20Mintable.Contract.ERC20MintableTransactor.contract.Transact(opts, method, params...) 5908 } 5909 5910 // Call invokes the (constant) contract method with params as input values and 5911 // sets the output to result. The result type might be a single field for simple 5912 // returns, a slice of interfaces for anonymous returns and a struct for named 5913 // returns. 5914 func (_ERC20Mintable *ERC20MintableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 5915 return _ERC20Mintable.Contract.contract.Call(opts, result, method, params...) 5916 } 5917 5918 // Transfer initiates a plain transaction to move funds to the contract, calling 5919 // its default method if one is available. 5920 func (_ERC20Mintable *ERC20MintableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 5921 return _ERC20Mintable.Contract.contract.Transfer(opts) 5922 } 5923 5924 // Transact invokes the (paid) contract method with params as input values. 5925 func (_ERC20Mintable *ERC20MintableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 5926 return _ERC20Mintable.Contract.contract.Transact(opts, method, params...) 5927 } 5928 5929 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 5930 // 5931 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 5932 func (_ERC20Mintable *ERC20MintableCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 5933 var ( 5934 ret0 = new(*big.Int) 5935 ) 5936 out := ret0 5937 err := _ERC20Mintable.contract.Call(opts, out, "allowance", owner, spender) 5938 return *ret0, err 5939 } 5940 5941 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 5942 // 5943 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 5944 func (_ERC20Mintable *ERC20MintableSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 5945 return _ERC20Mintable.Contract.Allowance(&_ERC20Mintable.CallOpts, owner, spender) 5946 } 5947 5948 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 5949 // 5950 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 5951 func (_ERC20Mintable *ERC20MintableCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 5952 return _ERC20Mintable.Contract.Allowance(&_ERC20Mintable.CallOpts, owner, spender) 5953 } 5954 5955 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 5956 // 5957 // Solidity: function balanceOf(address account) constant returns(uint256) 5958 func (_ERC20Mintable *ERC20MintableCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 5959 var ( 5960 ret0 = new(*big.Int) 5961 ) 5962 out := ret0 5963 err := _ERC20Mintable.contract.Call(opts, out, "balanceOf", account) 5964 return *ret0, err 5965 } 5966 5967 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 5968 // 5969 // Solidity: function balanceOf(address account) constant returns(uint256) 5970 func (_ERC20Mintable *ERC20MintableSession) BalanceOf(account common.Address) (*big.Int, error) { 5971 return _ERC20Mintable.Contract.BalanceOf(&_ERC20Mintable.CallOpts, account) 5972 } 5973 5974 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 5975 // 5976 // Solidity: function balanceOf(address account) constant returns(uint256) 5977 func (_ERC20Mintable *ERC20MintableCallerSession) BalanceOf(account common.Address) (*big.Int, error) { 5978 return _ERC20Mintable.Contract.BalanceOf(&_ERC20Mintable.CallOpts, account) 5979 } 5980 5981 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 5982 // 5983 // Solidity: function isMinter(address account) constant returns(bool) 5984 func (_ERC20Mintable *ERC20MintableCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) { 5985 var ( 5986 ret0 = new(bool) 5987 ) 5988 out := ret0 5989 err := _ERC20Mintable.contract.Call(opts, out, "isMinter", account) 5990 return *ret0, err 5991 } 5992 5993 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 5994 // 5995 // Solidity: function isMinter(address account) constant returns(bool) 5996 func (_ERC20Mintable *ERC20MintableSession) IsMinter(account common.Address) (bool, error) { 5997 return _ERC20Mintable.Contract.IsMinter(&_ERC20Mintable.CallOpts, account) 5998 } 5999 6000 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 6001 // 6002 // Solidity: function isMinter(address account) constant returns(bool) 6003 func (_ERC20Mintable *ERC20MintableCallerSession) IsMinter(account common.Address) (bool, error) { 6004 return _ERC20Mintable.Contract.IsMinter(&_ERC20Mintable.CallOpts, account) 6005 } 6006 6007 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 6008 // 6009 // Solidity: function totalSupply() constant returns(uint256) 6010 func (_ERC20Mintable *ERC20MintableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 6011 var ( 6012 ret0 = new(*big.Int) 6013 ) 6014 out := ret0 6015 err := _ERC20Mintable.contract.Call(opts, out, "totalSupply") 6016 return *ret0, err 6017 } 6018 6019 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 6020 // 6021 // Solidity: function totalSupply() constant returns(uint256) 6022 func (_ERC20Mintable *ERC20MintableSession) TotalSupply() (*big.Int, error) { 6023 return _ERC20Mintable.Contract.TotalSupply(&_ERC20Mintable.CallOpts) 6024 } 6025 6026 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 6027 // 6028 // Solidity: function totalSupply() constant returns(uint256) 6029 func (_ERC20Mintable *ERC20MintableCallerSession) TotalSupply() (*big.Int, error) { 6030 return _ERC20Mintable.Contract.TotalSupply(&_ERC20Mintable.CallOpts) 6031 } 6032 6033 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 6034 // 6035 // Solidity: function addMinter(address account) returns() 6036 func (_ERC20Mintable *ERC20MintableTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) { 6037 return _ERC20Mintable.contract.Transact(opts, "addMinter", account) 6038 } 6039 6040 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 6041 // 6042 // Solidity: function addMinter(address account) returns() 6043 func (_ERC20Mintable *ERC20MintableSession) AddMinter(account common.Address) (*types.Transaction, error) { 6044 return _ERC20Mintable.Contract.AddMinter(&_ERC20Mintable.TransactOpts, account) 6045 } 6046 6047 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 6048 // 6049 // Solidity: function addMinter(address account) returns() 6050 func (_ERC20Mintable *ERC20MintableTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) { 6051 return _ERC20Mintable.Contract.AddMinter(&_ERC20Mintable.TransactOpts, account) 6052 } 6053 6054 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 6055 // 6056 // Solidity: function approve(address spender, uint256 amount) returns(bool) 6057 func (_ERC20Mintable *ERC20MintableTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 6058 return _ERC20Mintable.contract.Transact(opts, "approve", spender, amount) 6059 } 6060 6061 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 6062 // 6063 // Solidity: function approve(address spender, uint256 amount) returns(bool) 6064 func (_ERC20Mintable *ERC20MintableSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 6065 return _ERC20Mintable.Contract.Approve(&_ERC20Mintable.TransactOpts, spender, amount) 6066 } 6067 6068 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 6069 // 6070 // Solidity: function approve(address spender, uint256 amount) returns(bool) 6071 func (_ERC20Mintable *ERC20MintableTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 6072 return _ERC20Mintable.Contract.Approve(&_ERC20Mintable.TransactOpts, spender, amount) 6073 } 6074 6075 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 6076 // 6077 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 6078 func (_ERC20Mintable *ERC20MintableTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 6079 return _ERC20Mintable.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) 6080 } 6081 6082 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 6083 // 6084 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 6085 func (_ERC20Mintable *ERC20MintableSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 6086 return _ERC20Mintable.Contract.DecreaseAllowance(&_ERC20Mintable.TransactOpts, spender, subtractedValue) 6087 } 6088 6089 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 6090 // 6091 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 6092 func (_ERC20Mintable *ERC20MintableTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 6093 return _ERC20Mintable.Contract.DecreaseAllowance(&_ERC20Mintable.TransactOpts, spender, subtractedValue) 6094 } 6095 6096 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 6097 // 6098 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 6099 func (_ERC20Mintable *ERC20MintableTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 6100 return _ERC20Mintable.contract.Transact(opts, "increaseAllowance", spender, addedValue) 6101 } 6102 6103 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 6104 // 6105 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 6106 func (_ERC20Mintable *ERC20MintableSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 6107 return _ERC20Mintable.Contract.IncreaseAllowance(&_ERC20Mintable.TransactOpts, spender, addedValue) 6108 } 6109 6110 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 6111 // 6112 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 6113 func (_ERC20Mintable *ERC20MintableTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 6114 return _ERC20Mintable.Contract.IncreaseAllowance(&_ERC20Mintable.TransactOpts, spender, addedValue) 6115 } 6116 6117 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 6118 // 6119 // Solidity: function mint(address account, uint256 amount) returns(bool) 6120 func (_ERC20Mintable *ERC20MintableTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { 6121 return _ERC20Mintable.contract.Transact(opts, "mint", account, amount) 6122 } 6123 6124 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 6125 // 6126 // Solidity: function mint(address account, uint256 amount) returns(bool) 6127 func (_ERC20Mintable *ERC20MintableSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { 6128 return _ERC20Mintable.Contract.Mint(&_ERC20Mintable.TransactOpts, account, amount) 6129 } 6130 6131 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 6132 // 6133 // Solidity: function mint(address account, uint256 amount) returns(bool) 6134 func (_ERC20Mintable *ERC20MintableTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { 6135 return _ERC20Mintable.Contract.Mint(&_ERC20Mintable.TransactOpts, account, amount) 6136 } 6137 6138 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 6139 // 6140 // Solidity: function renounceMinter() returns() 6141 func (_ERC20Mintable *ERC20MintableTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) { 6142 return _ERC20Mintable.contract.Transact(opts, "renounceMinter") 6143 } 6144 6145 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 6146 // 6147 // Solidity: function renounceMinter() returns() 6148 func (_ERC20Mintable *ERC20MintableSession) RenounceMinter() (*types.Transaction, error) { 6149 return _ERC20Mintable.Contract.RenounceMinter(&_ERC20Mintable.TransactOpts) 6150 } 6151 6152 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 6153 // 6154 // Solidity: function renounceMinter() returns() 6155 func (_ERC20Mintable *ERC20MintableTransactorSession) RenounceMinter() (*types.Transaction, error) { 6156 return _ERC20Mintable.Contract.RenounceMinter(&_ERC20Mintable.TransactOpts) 6157 } 6158 6159 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 6160 // 6161 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 6162 func (_ERC20Mintable *ERC20MintableTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 6163 return _ERC20Mintable.contract.Transact(opts, "transfer", recipient, amount) 6164 } 6165 6166 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 6167 // 6168 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 6169 func (_ERC20Mintable *ERC20MintableSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 6170 return _ERC20Mintable.Contract.Transfer(&_ERC20Mintable.TransactOpts, recipient, amount) 6171 } 6172 6173 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 6174 // 6175 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 6176 func (_ERC20Mintable *ERC20MintableTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 6177 return _ERC20Mintable.Contract.Transfer(&_ERC20Mintable.TransactOpts, recipient, amount) 6178 } 6179 6180 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 6181 // 6182 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 6183 func (_ERC20Mintable *ERC20MintableTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 6184 return _ERC20Mintable.contract.Transact(opts, "transferFrom", sender, recipient, amount) 6185 } 6186 6187 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 6188 // 6189 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 6190 func (_ERC20Mintable *ERC20MintableSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 6191 return _ERC20Mintable.Contract.TransferFrom(&_ERC20Mintable.TransactOpts, sender, recipient, amount) 6192 } 6193 6194 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 6195 // 6196 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 6197 func (_ERC20Mintable *ERC20MintableTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 6198 return _ERC20Mintable.Contract.TransferFrom(&_ERC20Mintable.TransactOpts, sender, recipient, amount) 6199 } 6200 6201 // ERC20MintableApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20Mintable contract. 6202 type ERC20MintableApprovalIterator struct { 6203 Event *ERC20MintableApproval // Event containing the contract specifics and raw log 6204 6205 contract *bind.BoundContract // Generic contract to use for unpacking event data 6206 event string // Event name to use for unpacking event data 6207 6208 logs chan types.Log // Log channel receiving the found contract events 6209 sub ethereum.Subscription // Subscription for errors, completion and termination 6210 done bool // Whether the subscription completed delivering logs 6211 fail error // Occurred error to stop iteration 6212 } 6213 6214 // Next advances the iterator to the subsequent event, returning whether there 6215 // are any more events found. In case of a retrieval or parsing error, false is 6216 // returned and Error() can be queried for the exact failure. 6217 func (it *ERC20MintableApprovalIterator) Next() bool { 6218 // If the iterator failed, stop iterating 6219 if it.fail != nil { 6220 return false 6221 } 6222 // If the iterator completed, deliver directly whatever's available 6223 if it.done { 6224 select { 6225 case log := <-it.logs: 6226 it.Event = new(ERC20MintableApproval) 6227 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 6228 it.fail = err 6229 return false 6230 } 6231 it.Event.Raw = log 6232 return true 6233 6234 default: 6235 return false 6236 } 6237 } 6238 // Iterator still in progress, wait for either a data or an error event 6239 select { 6240 case log := <-it.logs: 6241 it.Event = new(ERC20MintableApproval) 6242 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 6243 it.fail = err 6244 return false 6245 } 6246 it.Event.Raw = log 6247 return true 6248 6249 case err := <-it.sub.Err(): 6250 it.done = true 6251 it.fail = err 6252 return it.Next() 6253 } 6254 } 6255 6256 // Error returns any retrieval or parsing error occurred during filtering. 6257 func (it *ERC20MintableApprovalIterator) Error() error { 6258 return it.fail 6259 } 6260 6261 // Close terminates the iteration process, releasing any pending underlying 6262 // resources. 6263 func (it *ERC20MintableApprovalIterator) Close() error { 6264 it.sub.Unsubscribe() 6265 return nil 6266 } 6267 6268 // ERC20MintableApproval represents a Approval event raised by the ERC20Mintable contract. 6269 type ERC20MintableApproval struct { 6270 Owner common.Address 6271 Spender common.Address 6272 Value *big.Int 6273 Raw types.Log // Blockchain specific contextual infos 6274 } 6275 6276 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 6277 // 6278 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 6279 func (_ERC20Mintable *ERC20MintableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20MintableApprovalIterator, error) { 6280 6281 var ownerRule []interface{} 6282 for _, ownerItem := range owner { 6283 ownerRule = append(ownerRule, ownerItem) 6284 } 6285 var spenderRule []interface{} 6286 for _, spenderItem := range spender { 6287 spenderRule = append(spenderRule, spenderItem) 6288 } 6289 6290 logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 6291 if err != nil { 6292 return nil, err 6293 } 6294 return &ERC20MintableApprovalIterator{contract: _ERC20Mintable.contract, event: "Approval", logs: logs, sub: sub}, nil 6295 } 6296 6297 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 6298 // 6299 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 6300 func (_ERC20Mintable *ERC20MintableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20MintableApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 6301 6302 var ownerRule []interface{} 6303 for _, ownerItem := range owner { 6304 ownerRule = append(ownerRule, ownerItem) 6305 } 6306 var spenderRule []interface{} 6307 for _, spenderItem := range spender { 6308 spenderRule = append(spenderRule, spenderItem) 6309 } 6310 6311 logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 6312 if err != nil { 6313 return nil, err 6314 } 6315 return event.NewSubscription(func(quit <-chan struct{}) error { 6316 defer sub.Unsubscribe() 6317 for { 6318 select { 6319 case log := <-logs: 6320 // New log arrived, parse the event and forward to the user 6321 event := new(ERC20MintableApproval) 6322 if err := _ERC20Mintable.contract.UnpackLog(event, "Approval", log); err != nil { 6323 return err 6324 } 6325 event.Raw = log 6326 6327 select { 6328 case sink <- event: 6329 case err := <-sub.Err(): 6330 return err 6331 case <-quit: 6332 return nil 6333 } 6334 case err := <-sub.Err(): 6335 return err 6336 case <-quit: 6337 return nil 6338 } 6339 } 6340 }), nil 6341 } 6342 6343 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 6344 // 6345 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 6346 func (_ERC20Mintable *ERC20MintableFilterer) ParseApproval(log types.Log) (*ERC20MintableApproval, error) { 6347 event := new(ERC20MintableApproval) 6348 if err := _ERC20Mintable.contract.UnpackLog(event, "Approval", log); err != nil { 6349 return nil, err 6350 } 6351 return event, nil 6352 } 6353 6354 // ERC20MintableMinterAddedIterator is returned from FilterMinterAdded and is used to iterate over the raw logs and unpacked data for MinterAdded events raised by the ERC20Mintable contract. 6355 type ERC20MintableMinterAddedIterator struct { 6356 Event *ERC20MintableMinterAdded // Event containing the contract specifics and raw log 6357 6358 contract *bind.BoundContract // Generic contract to use for unpacking event data 6359 event string // Event name to use for unpacking event data 6360 6361 logs chan types.Log // Log channel receiving the found contract events 6362 sub ethereum.Subscription // Subscription for errors, completion and termination 6363 done bool // Whether the subscription completed delivering logs 6364 fail error // Occurred error to stop iteration 6365 } 6366 6367 // Next advances the iterator to the subsequent event, returning whether there 6368 // are any more events found. In case of a retrieval or parsing error, false is 6369 // returned and Error() can be queried for the exact failure. 6370 func (it *ERC20MintableMinterAddedIterator) Next() bool { 6371 // If the iterator failed, stop iterating 6372 if it.fail != nil { 6373 return false 6374 } 6375 // If the iterator completed, deliver directly whatever's available 6376 if it.done { 6377 select { 6378 case log := <-it.logs: 6379 it.Event = new(ERC20MintableMinterAdded) 6380 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 6381 it.fail = err 6382 return false 6383 } 6384 it.Event.Raw = log 6385 return true 6386 6387 default: 6388 return false 6389 } 6390 } 6391 // Iterator still in progress, wait for either a data or an error event 6392 select { 6393 case log := <-it.logs: 6394 it.Event = new(ERC20MintableMinterAdded) 6395 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 6396 it.fail = err 6397 return false 6398 } 6399 it.Event.Raw = log 6400 return true 6401 6402 case err := <-it.sub.Err(): 6403 it.done = true 6404 it.fail = err 6405 return it.Next() 6406 } 6407 } 6408 6409 // Error returns any retrieval or parsing error occurred during filtering. 6410 func (it *ERC20MintableMinterAddedIterator) Error() error { 6411 return it.fail 6412 } 6413 6414 // Close terminates the iteration process, releasing any pending underlying 6415 // resources. 6416 func (it *ERC20MintableMinterAddedIterator) Close() error { 6417 it.sub.Unsubscribe() 6418 return nil 6419 } 6420 6421 // ERC20MintableMinterAdded represents a MinterAdded event raised by the ERC20Mintable contract. 6422 type ERC20MintableMinterAdded struct { 6423 Account common.Address 6424 Raw types.Log // Blockchain specific contextual infos 6425 } 6426 6427 // FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 6428 // 6429 // Solidity: event MinterAdded(address indexed account) 6430 func (_ERC20Mintable *ERC20MintableFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*ERC20MintableMinterAddedIterator, error) { 6431 6432 var accountRule []interface{} 6433 for _, accountItem := range account { 6434 accountRule = append(accountRule, accountItem) 6435 } 6436 6437 logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "MinterAdded", accountRule) 6438 if err != nil { 6439 return nil, err 6440 } 6441 return &ERC20MintableMinterAddedIterator{contract: _ERC20Mintable.contract, event: "MinterAdded", logs: logs, sub: sub}, nil 6442 } 6443 6444 // WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 6445 // 6446 // Solidity: event MinterAdded(address indexed account) 6447 func (_ERC20Mintable *ERC20MintableFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *ERC20MintableMinterAdded, account []common.Address) (event.Subscription, error) { 6448 6449 var accountRule []interface{} 6450 for _, accountItem := range account { 6451 accountRule = append(accountRule, accountItem) 6452 } 6453 6454 logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "MinterAdded", accountRule) 6455 if err != nil { 6456 return nil, err 6457 } 6458 return event.NewSubscription(func(quit <-chan struct{}) error { 6459 defer sub.Unsubscribe() 6460 for { 6461 select { 6462 case log := <-logs: 6463 // New log arrived, parse the event and forward to the user 6464 event := new(ERC20MintableMinterAdded) 6465 if err := _ERC20Mintable.contract.UnpackLog(event, "MinterAdded", log); err != nil { 6466 return err 6467 } 6468 event.Raw = log 6469 6470 select { 6471 case sink <- event: 6472 case err := <-sub.Err(): 6473 return err 6474 case <-quit: 6475 return nil 6476 } 6477 case err := <-sub.Err(): 6478 return err 6479 case <-quit: 6480 return nil 6481 } 6482 } 6483 }), nil 6484 } 6485 6486 // ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 6487 // 6488 // Solidity: event MinterAdded(address indexed account) 6489 func (_ERC20Mintable *ERC20MintableFilterer) ParseMinterAdded(log types.Log) (*ERC20MintableMinterAdded, error) { 6490 event := new(ERC20MintableMinterAdded) 6491 if err := _ERC20Mintable.contract.UnpackLog(event, "MinterAdded", log); err != nil { 6492 return nil, err 6493 } 6494 return event, nil 6495 } 6496 6497 // ERC20MintableMinterRemovedIterator is returned from FilterMinterRemoved and is used to iterate over the raw logs and unpacked data for MinterRemoved events raised by the ERC20Mintable contract. 6498 type ERC20MintableMinterRemovedIterator struct { 6499 Event *ERC20MintableMinterRemoved // Event containing the contract specifics and raw log 6500 6501 contract *bind.BoundContract // Generic contract to use for unpacking event data 6502 event string // Event name to use for unpacking event data 6503 6504 logs chan types.Log // Log channel receiving the found contract events 6505 sub ethereum.Subscription // Subscription for errors, completion and termination 6506 done bool // Whether the subscription completed delivering logs 6507 fail error // Occurred error to stop iteration 6508 } 6509 6510 // Next advances the iterator to the subsequent event, returning whether there 6511 // are any more events found. In case of a retrieval or parsing error, false is 6512 // returned and Error() can be queried for the exact failure. 6513 func (it *ERC20MintableMinterRemovedIterator) Next() bool { 6514 // If the iterator failed, stop iterating 6515 if it.fail != nil { 6516 return false 6517 } 6518 // If the iterator completed, deliver directly whatever's available 6519 if it.done { 6520 select { 6521 case log := <-it.logs: 6522 it.Event = new(ERC20MintableMinterRemoved) 6523 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 6524 it.fail = err 6525 return false 6526 } 6527 it.Event.Raw = log 6528 return true 6529 6530 default: 6531 return false 6532 } 6533 } 6534 // Iterator still in progress, wait for either a data or an error event 6535 select { 6536 case log := <-it.logs: 6537 it.Event = new(ERC20MintableMinterRemoved) 6538 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 6539 it.fail = err 6540 return false 6541 } 6542 it.Event.Raw = log 6543 return true 6544 6545 case err := <-it.sub.Err(): 6546 it.done = true 6547 it.fail = err 6548 return it.Next() 6549 } 6550 } 6551 6552 // Error returns any retrieval or parsing error occurred during filtering. 6553 func (it *ERC20MintableMinterRemovedIterator) Error() error { 6554 return it.fail 6555 } 6556 6557 // Close terminates the iteration process, releasing any pending underlying 6558 // resources. 6559 func (it *ERC20MintableMinterRemovedIterator) Close() error { 6560 it.sub.Unsubscribe() 6561 return nil 6562 } 6563 6564 // ERC20MintableMinterRemoved represents a MinterRemoved event raised by the ERC20Mintable contract. 6565 type ERC20MintableMinterRemoved struct { 6566 Account common.Address 6567 Raw types.Log // Blockchain specific contextual infos 6568 } 6569 6570 // FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 6571 // 6572 // Solidity: event MinterRemoved(address indexed account) 6573 func (_ERC20Mintable *ERC20MintableFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*ERC20MintableMinterRemovedIterator, error) { 6574 6575 var accountRule []interface{} 6576 for _, accountItem := range account { 6577 accountRule = append(accountRule, accountItem) 6578 } 6579 6580 logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "MinterRemoved", accountRule) 6581 if err != nil { 6582 return nil, err 6583 } 6584 return &ERC20MintableMinterRemovedIterator{contract: _ERC20Mintable.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil 6585 } 6586 6587 // WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 6588 // 6589 // Solidity: event MinterRemoved(address indexed account) 6590 func (_ERC20Mintable *ERC20MintableFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *ERC20MintableMinterRemoved, account []common.Address) (event.Subscription, error) { 6591 6592 var accountRule []interface{} 6593 for _, accountItem := range account { 6594 accountRule = append(accountRule, accountItem) 6595 } 6596 6597 logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "MinterRemoved", accountRule) 6598 if err != nil { 6599 return nil, err 6600 } 6601 return event.NewSubscription(func(quit <-chan struct{}) error { 6602 defer sub.Unsubscribe() 6603 for { 6604 select { 6605 case log := <-logs: 6606 // New log arrived, parse the event and forward to the user 6607 event := new(ERC20MintableMinterRemoved) 6608 if err := _ERC20Mintable.contract.UnpackLog(event, "MinterRemoved", log); err != nil { 6609 return err 6610 } 6611 event.Raw = log 6612 6613 select { 6614 case sink <- event: 6615 case err := <-sub.Err(): 6616 return err 6617 case <-quit: 6618 return nil 6619 } 6620 case err := <-sub.Err(): 6621 return err 6622 case <-quit: 6623 return nil 6624 } 6625 } 6626 }), nil 6627 } 6628 6629 // ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 6630 // 6631 // Solidity: event MinterRemoved(address indexed account) 6632 func (_ERC20Mintable *ERC20MintableFilterer) ParseMinterRemoved(log types.Log) (*ERC20MintableMinterRemoved, error) { 6633 event := new(ERC20MintableMinterRemoved) 6634 if err := _ERC20Mintable.contract.UnpackLog(event, "MinterRemoved", log); err != nil { 6635 return nil, err 6636 } 6637 return event, nil 6638 } 6639 6640 // ERC20MintableTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20Mintable contract. 6641 type ERC20MintableTransferIterator struct { 6642 Event *ERC20MintableTransfer // Event containing the contract specifics and raw log 6643 6644 contract *bind.BoundContract // Generic contract to use for unpacking event data 6645 event string // Event name to use for unpacking event data 6646 6647 logs chan types.Log // Log channel receiving the found contract events 6648 sub ethereum.Subscription // Subscription for errors, completion and termination 6649 done bool // Whether the subscription completed delivering logs 6650 fail error // Occurred error to stop iteration 6651 } 6652 6653 // Next advances the iterator to the subsequent event, returning whether there 6654 // are any more events found. In case of a retrieval or parsing error, false is 6655 // returned and Error() can be queried for the exact failure. 6656 func (it *ERC20MintableTransferIterator) Next() bool { 6657 // If the iterator failed, stop iterating 6658 if it.fail != nil { 6659 return false 6660 } 6661 // If the iterator completed, deliver directly whatever's available 6662 if it.done { 6663 select { 6664 case log := <-it.logs: 6665 it.Event = new(ERC20MintableTransfer) 6666 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 6667 it.fail = err 6668 return false 6669 } 6670 it.Event.Raw = log 6671 return true 6672 6673 default: 6674 return false 6675 } 6676 } 6677 // Iterator still in progress, wait for either a data or an error event 6678 select { 6679 case log := <-it.logs: 6680 it.Event = new(ERC20MintableTransfer) 6681 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 6682 it.fail = err 6683 return false 6684 } 6685 it.Event.Raw = log 6686 return true 6687 6688 case err := <-it.sub.Err(): 6689 it.done = true 6690 it.fail = err 6691 return it.Next() 6692 } 6693 } 6694 6695 // Error returns any retrieval or parsing error occurred during filtering. 6696 func (it *ERC20MintableTransferIterator) Error() error { 6697 return it.fail 6698 } 6699 6700 // Close terminates the iteration process, releasing any pending underlying 6701 // resources. 6702 func (it *ERC20MintableTransferIterator) Close() error { 6703 it.sub.Unsubscribe() 6704 return nil 6705 } 6706 6707 // ERC20MintableTransfer represents a Transfer event raised by the ERC20Mintable contract. 6708 type ERC20MintableTransfer struct { 6709 From common.Address 6710 To common.Address 6711 Value *big.Int 6712 Raw types.Log // Blockchain specific contextual infos 6713 } 6714 6715 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 6716 // 6717 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 6718 func (_ERC20Mintable *ERC20MintableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20MintableTransferIterator, error) { 6719 6720 var fromRule []interface{} 6721 for _, fromItem := range from { 6722 fromRule = append(fromRule, fromItem) 6723 } 6724 var toRule []interface{} 6725 for _, toItem := range to { 6726 toRule = append(toRule, toItem) 6727 } 6728 6729 logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 6730 if err != nil { 6731 return nil, err 6732 } 6733 return &ERC20MintableTransferIterator{contract: _ERC20Mintable.contract, event: "Transfer", logs: logs, sub: sub}, nil 6734 } 6735 6736 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 6737 // 6738 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 6739 func (_ERC20Mintable *ERC20MintableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20MintableTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 6740 6741 var fromRule []interface{} 6742 for _, fromItem := range from { 6743 fromRule = append(fromRule, fromItem) 6744 } 6745 var toRule []interface{} 6746 for _, toItem := range to { 6747 toRule = append(toRule, toItem) 6748 } 6749 6750 logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 6751 if err != nil { 6752 return nil, err 6753 } 6754 return event.NewSubscription(func(quit <-chan struct{}) error { 6755 defer sub.Unsubscribe() 6756 for { 6757 select { 6758 case log := <-logs: 6759 // New log arrived, parse the event and forward to the user 6760 event := new(ERC20MintableTransfer) 6761 if err := _ERC20Mintable.contract.UnpackLog(event, "Transfer", log); err != nil { 6762 return err 6763 } 6764 event.Raw = log 6765 6766 select { 6767 case sink <- event: 6768 case err := <-sub.Err(): 6769 return err 6770 case <-quit: 6771 return nil 6772 } 6773 case err := <-sub.Err(): 6774 return err 6775 case <-quit: 6776 return nil 6777 } 6778 } 6779 }), nil 6780 } 6781 6782 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 6783 // 6784 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 6785 func (_ERC20Mintable *ERC20MintableFilterer) ParseTransfer(log types.Log) (*ERC20MintableTransfer, error) { 6786 event := new(ERC20MintableTransfer) 6787 if err := _ERC20Mintable.contract.UnpackLog(event, "Transfer", log); err != nil { 6788 return nil, err 6789 } 6790 return event, nil 6791 } 6792 6793 // ERC20OnApproveABI is the input ABI used to generate the binding from. 6794 const ERC20OnApproveABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"INTERFACE_ID_ON_APPROVE\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"approveAndCall\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"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\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 6795 6796 // ERC20OnApproveFuncSigs maps the 4-byte function signature to its string representation. 6797 var ERC20OnApproveFuncSigs = map[string]string{ 6798 "6cd28f9a": "INTERFACE_ID_ON_APPROVE()", 6799 "dd62ed3e": "allowance(address,address)", 6800 "095ea7b3": "approve(address,uint256)", 6801 "cae9ca51": "approveAndCall(address,uint256,bytes)", 6802 "70a08231": "balanceOf(address)", 6803 "a457c2d7": "decreaseAllowance(address,uint256)", 6804 "39509351": "increaseAllowance(address,uint256)", 6805 "18160ddd": "totalSupply()", 6806 "a9059cbb": "transfer(address,uint256)", 6807 "23b872dd": "transferFrom(address,address,uint256)", 6808 } 6809 6810 // ERC20OnApproveBin is the compiled bytecode used for deploying new contracts. 6811 var ERC20OnApproveBin = "0x6080604052610dc0806100136000396000f3fe608060405234801561001057600080fd5b506004361061009e5760003560e01c806370a082311161006657806370a0823114610184578063a457c2d7146101aa578063a9059cbb146101d6578063cae9ca5114610202578063dd62ed3e146102bd5761009e565b8063095ea7b3146100a357806318160ddd146100e357806323b872dd146100fd57806339509351146101335780636cd28f9a1461015f575b600080fd5b6100cf600480360360408110156100b957600080fd5b506001600160a01b0381351690602001356102eb565b604080519115158252519081900360200190f35b6100eb610308565b60408051918252519081900360200190f35b6100cf6004803603606081101561011357600080fd5b506001600160a01b0381358116916020810135909116906040013561030e565b6100cf6004803603604081101561014957600080fd5b506001600160a01b03813516906020013561039c565b6101676103f0565b604080516001600160e01b03199092168252519081900360200190f35b6100eb6004803603602081101561019a57600080fd5b50356001600160a01b031661040b565b6100cf600480360360408110156101c057600080fd5b506001600160a01b038135169060200135610426565b6100cf600480360360408110156101ec57600080fd5b506001600160a01b038135169060200135610494565b6100cf6004803603606081101561021857600080fd5b6001600160a01b038235169160208101359181019060608101604082013564010000000081111561024857600080fd5b82018360208201111561025a57600080fd5b8035906020019184600183028401116401000000008311171561027c57600080fd5b91908080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152509295506104a8945050505050565b6100eb600480360360408110156102d357600080fd5b506001600160a01b03813581169160200135166104c9565b60006102ff6102f86104f4565b84846104f8565b50600192915050565b60025490565b600061031b8484846105e4565b610391846103276104f4565b61038c85604051806060016040528060288152602001610cf6602891396001600160a01b038a166000908152600160205260408120906103656104f4565b6001600160a01b03168152602081019190915260400160002054919063ffffffff61074016565b6104f8565b5060015b9392505050565b60006102ff6103a96104f4565b8461038c85600160006103ba6104f4565b6001600160a01b03908116825260208083019390935260409182016000908120918c16815292529020549063ffffffff6107d716565b604051806028610cce82396028019050604051809103902081565b6001600160a01b031660009081526020819052604090205490565b60006102ff6104336104f4565b8461038c85604051806060016040528060258152602001610d67602591396001600061045d6104f4565b6001600160a01b03908116825260208083019390935260409182016000908120918d1681529252902054919063ffffffff61074016565b60006102ff6104a16104f4565b84846105e4565b60006104b484846102eb565b6104bd57600080fd5b61039533858585610831565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b3390565b6001600160a01b03831661053d5760405162461bcd60e51b8152600401808060200182810382526024815260200180610d436024913960400191505060405180910390fd5b6001600160a01b0382166105825760405162461bcd60e51b8152600401808060200182810382526022815260200180610c556022913960400191505060405180910390fd5b6001600160a01b03808416600081815260016020908152604080832094871680845294825291829020859055815185815291517f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259281900390910190a3505050565b6001600160a01b0383166106295760405162461bcd60e51b8152600401808060200182810382526025815260200180610d1e6025913960400191505060405180910390fd5b6001600160a01b03821661066e5760405162461bcd60e51b8152600401808060200182810382526023815260200180610c326023913960400191505060405180910390fd5b6106b181604051806060016040528060268152602001610ca8602691396001600160a01b038616600090815260208190526040902054919063ffffffff61074016565b6001600160a01b0380851660009081526020819052604080822093909355908416815220546106e6908263ffffffff6107d716565b6001600160a01b038084166000818152602081815260409182902094909455805185815290519193928716927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef92918290030190a3505050565b600081848411156107cf5760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b8381101561079457818101518382015260200161077c565b50505050905090810190601f1680156107c15780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b505050900390565b600082820183811015610395576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b610853836040518080610cce6028913960280190506040518091039020610a87565b61088e5760405162461bcd60e51b8152600401808060200182810382526031815260200180610c776031913960400191505060405180910390fd5b60006060846001600160a01b03166040518080610cce60289139602801905060405180910390208787878760405160240180856001600160a01b03166001600160a01b03168152602001846001600160a01b03166001600160a01b0316815260200183815260200180602001828103825283818151815260200191508051906020019080838360005b8381101561092f578181015183820152602001610917565b50505050905090810190601f16801561095c5780820380516001836020036101000a031916815260200191505b5060408051601f198184030181529181526020820180516001600160e01b03166001600160e01b0319909a16999099178952518151919890975087965094509250829150849050835b602083106109c45780518252601f1990920191602091820191016109a5565b6001836020036101000a0380198251168184511680821785525050505050509050019150506000604051808303816000865af19150503d8060008114610a26576040519150601f19603f3d011682016040523d82523d6000602084013e610a2b565b606091505b5091509150818190610a7e5760405162461bcd60e51b815260206004820181815283516024840152835190928392604490910191908501908083836000831561079457818101518382015260200161077c565b50505050505050565b6000610a9283610aa3565b801561039557506103958383610ad7565b6000610ab6826301ffc9a760e01b610ad7565b8015610ad15750610acf826001600160e01b0319610ad7565b155b92915050565b6000806000610ae68585610afd565b91509150818015610af45750805b95945050505050565b604080516001600160e01b0319831660248083019190915282518083039091018152604490910182526020810180516001600160e01b03166301ffc9a760e01b1781529151815160009384939284926060926001600160a01b038a169261753092879282918083835b60208310610b855780518252601f199092019160209182019101610b66565b6001836020036101000a0380198251168184511680821785525050505050509050019150506000604051808303818686fa925050503d8060008114610be6576040519150601f19603f3d011682016040523d82523d6000602084013e610beb565b606091505b5091509150602081511015610c095760008094509450505050610c2a565b81818060200190516020811015610c1f57600080fd5b505190955093505050505b925092905056fe45524332303a207472616e7366657220746f20746865207a65726f206164647265737345524332303a20617070726f766520746f20746865207a65726f206164647265737345524332304f6e417070726f76653a207370656e64657220646f65736e277420737570706f7274206f6e417070726f766545524332303a207472616e7366657220616d6f756e7420657863656564732062616c616e63656f6e417070726f766528616464726573732c616464726573732c75696e743235362c62797465732945524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e636545524332303a207472616e736665722066726f6d20746865207a65726f206164647265737345524332303a20617070726f76652066726f6d20746865207a65726f206164647265737345524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726fa265627a7a723158205f38639f33e199b2a44d46fed86192ba1daf836a08c11f82aa877b89bb0dc9fc64736f6c634300050c0032" 6812 6813 // DeployERC20OnApprove deploys a new Ethereum contract, binding an instance of ERC20OnApprove to it. 6814 func DeployERC20OnApprove(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20OnApprove, error) { 6815 parsed, err := abi.JSON(strings.NewReader(ERC20OnApproveABI)) 6816 if err != nil { 6817 return common.Address{}, nil, nil, err 6818 } 6819 6820 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20OnApproveBin), backend) 6821 if err != nil { 6822 return common.Address{}, nil, nil, err 6823 } 6824 return address, tx, &ERC20OnApprove{ERC20OnApproveCaller: ERC20OnApproveCaller{contract: contract}, ERC20OnApproveTransactor: ERC20OnApproveTransactor{contract: contract}, ERC20OnApproveFilterer: ERC20OnApproveFilterer{contract: contract}}, nil 6825 } 6826 6827 // ERC20OnApprove is an auto generated Go binding around an Ethereum contract. 6828 type ERC20OnApprove struct { 6829 ERC20OnApproveCaller // Read-only binding to the contract 6830 ERC20OnApproveTransactor // Write-only binding to the contract 6831 ERC20OnApproveFilterer // Log filterer for contract events 6832 } 6833 6834 // ERC20OnApproveCaller is an auto generated read-only Go binding around an Ethereum contract. 6835 type ERC20OnApproveCaller struct { 6836 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6837 } 6838 6839 // ERC20OnApproveTransactor is an auto generated write-only Go binding around an Ethereum contract. 6840 type ERC20OnApproveTransactor struct { 6841 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6842 } 6843 6844 // ERC20OnApproveFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 6845 type ERC20OnApproveFilterer struct { 6846 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6847 } 6848 6849 // ERC20OnApproveSession is an auto generated Go binding around an Ethereum contract, 6850 // with pre-set call and transact options. 6851 type ERC20OnApproveSession struct { 6852 Contract *ERC20OnApprove // Generic contract binding to set the session for 6853 CallOpts bind.CallOpts // Call options to use throughout this session 6854 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 6855 } 6856 6857 // ERC20OnApproveCallerSession is an auto generated read-only Go binding around an Ethereum contract, 6858 // with pre-set call options. 6859 type ERC20OnApproveCallerSession struct { 6860 Contract *ERC20OnApproveCaller // Generic contract caller binding to set the session for 6861 CallOpts bind.CallOpts // Call options to use throughout this session 6862 } 6863 6864 // ERC20OnApproveTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 6865 // with pre-set transact options. 6866 type ERC20OnApproveTransactorSession struct { 6867 Contract *ERC20OnApproveTransactor // Generic contract transactor binding to set the session for 6868 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 6869 } 6870 6871 // ERC20OnApproveRaw is an auto generated low-level Go binding around an Ethereum contract. 6872 type ERC20OnApproveRaw struct { 6873 Contract *ERC20OnApprove // Generic contract binding to access the raw methods on 6874 } 6875 6876 // ERC20OnApproveCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 6877 type ERC20OnApproveCallerRaw struct { 6878 Contract *ERC20OnApproveCaller // Generic read-only contract binding to access the raw methods on 6879 } 6880 6881 // ERC20OnApproveTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 6882 type ERC20OnApproveTransactorRaw struct { 6883 Contract *ERC20OnApproveTransactor // Generic write-only contract binding to access the raw methods on 6884 } 6885 6886 // NewERC20OnApprove creates a new instance of ERC20OnApprove, bound to a specific deployed contract. 6887 func NewERC20OnApprove(address common.Address, backend bind.ContractBackend) (*ERC20OnApprove, error) { 6888 contract, err := bindERC20OnApprove(address, backend, backend, backend) 6889 if err != nil { 6890 return nil, err 6891 } 6892 return &ERC20OnApprove{ERC20OnApproveCaller: ERC20OnApproveCaller{contract: contract}, ERC20OnApproveTransactor: ERC20OnApproveTransactor{contract: contract}, ERC20OnApproveFilterer: ERC20OnApproveFilterer{contract: contract}}, nil 6893 } 6894 6895 // NewERC20OnApproveCaller creates a new read-only instance of ERC20OnApprove, bound to a specific deployed contract. 6896 func NewERC20OnApproveCaller(address common.Address, caller bind.ContractCaller) (*ERC20OnApproveCaller, error) { 6897 contract, err := bindERC20OnApprove(address, caller, nil, nil) 6898 if err != nil { 6899 return nil, err 6900 } 6901 return &ERC20OnApproveCaller{contract: contract}, nil 6902 } 6903 6904 // NewERC20OnApproveTransactor creates a new write-only instance of ERC20OnApprove, bound to a specific deployed contract. 6905 func NewERC20OnApproveTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20OnApproveTransactor, error) { 6906 contract, err := bindERC20OnApprove(address, nil, transactor, nil) 6907 if err != nil { 6908 return nil, err 6909 } 6910 return &ERC20OnApproveTransactor{contract: contract}, nil 6911 } 6912 6913 // NewERC20OnApproveFilterer creates a new log filterer instance of ERC20OnApprove, bound to a specific deployed contract. 6914 func NewERC20OnApproveFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20OnApproveFilterer, error) { 6915 contract, err := bindERC20OnApprove(address, nil, nil, filterer) 6916 if err != nil { 6917 return nil, err 6918 } 6919 return &ERC20OnApproveFilterer{contract: contract}, nil 6920 } 6921 6922 // bindERC20OnApprove binds a generic wrapper to an already deployed contract. 6923 func bindERC20OnApprove(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 6924 parsed, err := abi.JSON(strings.NewReader(ERC20OnApproveABI)) 6925 if err != nil { 6926 return nil, err 6927 } 6928 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 6929 } 6930 6931 // Call invokes the (constant) contract method with params as input values and 6932 // sets the output to result. The result type might be a single field for simple 6933 // returns, a slice of interfaces for anonymous returns and a struct for named 6934 // returns. 6935 func (_ERC20OnApprove *ERC20OnApproveRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 6936 return _ERC20OnApprove.Contract.ERC20OnApproveCaller.contract.Call(opts, result, method, params...) 6937 } 6938 6939 // Transfer initiates a plain transaction to move funds to the contract, calling 6940 // its default method if one is available. 6941 func (_ERC20OnApprove *ERC20OnApproveRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 6942 return _ERC20OnApprove.Contract.ERC20OnApproveTransactor.contract.Transfer(opts) 6943 } 6944 6945 // Transact invokes the (paid) contract method with params as input values. 6946 func (_ERC20OnApprove *ERC20OnApproveRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 6947 return _ERC20OnApprove.Contract.ERC20OnApproveTransactor.contract.Transact(opts, method, params...) 6948 } 6949 6950 // Call invokes the (constant) contract method with params as input values and 6951 // sets the output to result. The result type might be a single field for simple 6952 // returns, a slice of interfaces for anonymous returns and a struct for named 6953 // returns. 6954 func (_ERC20OnApprove *ERC20OnApproveCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 6955 return _ERC20OnApprove.Contract.contract.Call(opts, result, method, params...) 6956 } 6957 6958 // Transfer initiates a plain transaction to move funds to the contract, calling 6959 // its default method if one is available. 6960 func (_ERC20OnApprove *ERC20OnApproveTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 6961 return _ERC20OnApprove.Contract.contract.Transfer(opts) 6962 } 6963 6964 // Transact invokes the (paid) contract method with params as input values. 6965 func (_ERC20OnApprove *ERC20OnApproveTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 6966 return _ERC20OnApprove.Contract.contract.Transact(opts, method, params...) 6967 } 6968 6969 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 6970 // 6971 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 6972 func (_ERC20OnApprove *ERC20OnApproveCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) { 6973 var ( 6974 ret0 = new([4]byte) 6975 ) 6976 out := ret0 6977 err := _ERC20OnApprove.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE") 6978 return *ret0, err 6979 } 6980 6981 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 6982 // 6983 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 6984 func (_ERC20OnApprove *ERC20OnApproveSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 6985 return _ERC20OnApprove.Contract.INTERFACEIDONAPPROVE(&_ERC20OnApprove.CallOpts) 6986 } 6987 6988 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 6989 // 6990 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 6991 func (_ERC20OnApprove *ERC20OnApproveCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 6992 return _ERC20OnApprove.Contract.INTERFACEIDONAPPROVE(&_ERC20OnApprove.CallOpts) 6993 } 6994 6995 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 6996 // 6997 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 6998 func (_ERC20OnApprove *ERC20OnApproveCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 6999 var ( 7000 ret0 = new(*big.Int) 7001 ) 7002 out := ret0 7003 err := _ERC20OnApprove.contract.Call(opts, out, "allowance", owner, spender) 7004 return *ret0, err 7005 } 7006 7007 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 7008 // 7009 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 7010 func (_ERC20OnApprove *ERC20OnApproveSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 7011 return _ERC20OnApprove.Contract.Allowance(&_ERC20OnApprove.CallOpts, owner, spender) 7012 } 7013 7014 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 7015 // 7016 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 7017 func (_ERC20OnApprove *ERC20OnApproveCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 7018 return _ERC20OnApprove.Contract.Allowance(&_ERC20OnApprove.CallOpts, owner, spender) 7019 } 7020 7021 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 7022 // 7023 // Solidity: function balanceOf(address account) constant returns(uint256) 7024 func (_ERC20OnApprove *ERC20OnApproveCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 7025 var ( 7026 ret0 = new(*big.Int) 7027 ) 7028 out := ret0 7029 err := _ERC20OnApprove.contract.Call(opts, out, "balanceOf", account) 7030 return *ret0, err 7031 } 7032 7033 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 7034 // 7035 // Solidity: function balanceOf(address account) constant returns(uint256) 7036 func (_ERC20OnApprove *ERC20OnApproveSession) BalanceOf(account common.Address) (*big.Int, error) { 7037 return _ERC20OnApprove.Contract.BalanceOf(&_ERC20OnApprove.CallOpts, account) 7038 } 7039 7040 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 7041 // 7042 // Solidity: function balanceOf(address account) constant returns(uint256) 7043 func (_ERC20OnApprove *ERC20OnApproveCallerSession) BalanceOf(account common.Address) (*big.Int, error) { 7044 return _ERC20OnApprove.Contract.BalanceOf(&_ERC20OnApprove.CallOpts, account) 7045 } 7046 7047 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 7048 // 7049 // Solidity: function totalSupply() constant returns(uint256) 7050 func (_ERC20OnApprove *ERC20OnApproveCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 7051 var ( 7052 ret0 = new(*big.Int) 7053 ) 7054 out := ret0 7055 err := _ERC20OnApprove.contract.Call(opts, out, "totalSupply") 7056 return *ret0, err 7057 } 7058 7059 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 7060 // 7061 // Solidity: function totalSupply() constant returns(uint256) 7062 func (_ERC20OnApprove *ERC20OnApproveSession) TotalSupply() (*big.Int, error) { 7063 return _ERC20OnApprove.Contract.TotalSupply(&_ERC20OnApprove.CallOpts) 7064 } 7065 7066 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 7067 // 7068 // Solidity: function totalSupply() constant returns(uint256) 7069 func (_ERC20OnApprove *ERC20OnApproveCallerSession) TotalSupply() (*big.Int, error) { 7070 return _ERC20OnApprove.Contract.TotalSupply(&_ERC20OnApprove.CallOpts) 7071 } 7072 7073 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 7074 // 7075 // Solidity: function approve(address spender, uint256 amount) returns(bool) 7076 func (_ERC20OnApprove *ERC20OnApproveTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 7077 return _ERC20OnApprove.contract.Transact(opts, "approve", spender, amount) 7078 } 7079 7080 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 7081 // 7082 // Solidity: function approve(address spender, uint256 amount) returns(bool) 7083 func (_ERC20OnApprove *ERC20OnApproveSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 7084 return _ERC20OnApprove.Contract.Approve(&_ERC20OnApprove.TransactOpts, spender, amount) 7085 } 7086 7087 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 7088 // 7089 // Solidity: function approve(address spender, uint256 amount) returns(bool) 7090 func (_ERC20OnApprove *ERC20OnApproveTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 7091 return _ERC20OnApprove.Contract.Approve(&_ERC20OnApprove.TransactOpts, spender, amount) 7092 } 7093 7094 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 7095 // 7096 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 7097 func (_ERC20OnApprove *ERC20OnApproveTransactor) ApproveAndCall(opts *bind.TransactOpts, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 7098 return _ERC20OnApprove.contract.Transact(opts, "approveAndCall", spender, amount, data) 7099 } 7100 7101 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 7102 // 7103 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 7104 func (_ERC20OnApprove *ERC20OnApproveSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 7105 return _ERC20OnApprove.Contract.ApproveAndCall(&_ERC20OnApprove.TransactOpts, spender, amount, data) 7106 } 7107 7108 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 7109 // 7110 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 7111 func (_ERC20OnApprove *ERC20OnApproveTransactorSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 7112 return _ERC20OnApprove.Contract.ApproveAndCall(&_ERC20OnApprove.TransactOpts, spender, amount, data) 7113 } 7114 7115 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 7116 // 7117 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 7118 func (_ERC20OnApprove *ERC20OnApproveTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 7119 return _ERC20OnApprove.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) 7120 } 7121 7122 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 7123 // 7124 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 7125 func (_ERC20OnApprove *ERC20OnApproveSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 7126 return _ERC20OnApprove.Contract.DecreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, subtractedValue) 7127 } 7128 7129 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 7130 // 7131 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 7132 func (_ERC20OnApprove *ERC20OnApproveTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 7133 return _ERC20OnApprove.Contract.DecreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, subtractedValue) 7134 } 7135 7136 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 7137 // 7138 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 7139 func (_ERC20OnApprove *ERC20OnApproveTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 7140 return _ERC20OnApprove.contract.Transact(opts, "increaseAllowance", spender, addedValue) 7141 } 7142 7143 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 7144 // 7145 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 7146 func (_ERC20OnApprove *ERC20OnApproveSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 7147 return _ERC20OnApprove.Contract.IncreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, addedValue) 7148 } 7149 7150 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 7151 // 7152 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 7153 func (_ERC20OnApprove *ERC20OnApproveTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 7154 return _ERC20OnApprove.Contract.IncreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, addedValue) 7155 } 7156 7157 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 7158 // 7159 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 7160 func (_ERC20OnApprove *ERC20OnApproveTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7161 return _ERC20OnApprove.contract.Transact(opts, "transfer", recipient, amount) 7162 } 7163 7164 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 7165 // 7166 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 7167 func (_ERC20OnApprove *ERC20OnApproveSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7168 return _ERC20OnApprove.Contract.Transfer(&_ERC20OnApprove.TransactOpts, recipient, amount) 7169 } 7170 7171 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 7172 // 7173 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 7174 func (_ERC20OnApprove *ERC20OnApproveTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7175 return _ERC20OnApprove.Contract.Transfer(&_ERC20OnApprove.TransactOpts, recipient, amount) 7176 } 7177 7178 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 7179 // 7180 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 7181 func (_ERC20OnApprove *ERC20OnApproveTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7182 return _ERC20OnApprove.contract.Transact(opts, "transferFrom", sender, recipient, amount) 7183 } 7184 7185 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 7186 // 7187 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 7188 func (_ERC20OnApprove *ERC20OnApproveSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7189 return _ERC20OnApprove.Contract.TransferFrom(&_ERC20OnApprove.TransactOpts, sender, recipient, amount) 7190 } 7191 7192 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 7193 // 7194 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 7195 func (_ERC20OnApprove *ERC20OnApproveTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7196 return _ERC20OnApprove.Contract.TransferFrom(&_ERC20OnApprove.TransactOpts, sender, recipient, amount) 7197 } 7198 7199 // ERC20OnApproveApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the ERC20OnApprove contract. 7200 type ERC20OnApproveApprovalIterator struct { 7201 Event *ERC20OnApproveApproval // Event containing the contract specifics and raw log 7202 7203 contract *bind.BoundContract // Generic contract to use for unpacking event data 7204 event string // Event name to use for unpacking event data 7205 7206 logs chan types.Log // Log channel receiving the found contract events 7207 sub ethereum.Subscription // Subscription for errors, completion and termination 7208 done bool // Whether the subscription completed delivering logs 7209 fail error // Occurred error to stop iteration 7210 } 7211 7212 // Next advances the iterator to the subsequent event, returning whether there 7213 // are any more events found. In case of a retrieval or parsing error, false is 7214 // returned and Error() can be queried for the exact failure. 7215 func (it *ERC20OnApproveApprovalIterator) Next() bool { 7216 // If the iterator failed, stop iterating 7217 if it.fail != nil { 7218 return false 7219 } 7220 // If the iterator completed, deliver directly whatever's available 7221 if it.done { 7222 select { 7223 case log := <-it.logs: 7224 it.Event = new(ERC20OnApproveApproval) 7225 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 7226 it.fail = err 7227 return false 7228 } 7229 it.Event.Raw = log 7230 return true 7231 7232 default: 7233 return false 7234 } 7235 } 7236 // Iterator still in progress, wait for either a data or an error event 7237 select { 7238 case log := <-it.logs: 7239 it.Event = new(ERC20OnApproveApproval) 7240 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 7241 it.fail = err 7242 return false 7243 } 7244 it.Event.Raw = log 7245 return true 7246 7247 case err := <-it.sub.Err(): 7248 it.done = true 7249 it.fail = err 7250 return it.Next() 7251 } 7252 } 7253 7254 // Error returns any retrieval or parsing error occurred during filtering. 7255 func (it *ERC20OnApproveApprovalIterator) Error() error { 7256 return it.fail 7257 } 7258 7259 // Close terminates the iteration process, releasing any pending underlying 7260 // resources. 7261 func (it *ERC20OnApproveApprovalIterator) Close() error { 7262 it.sub.Unsubscribe() 7263 return nil 7264 } 7265 7266 // ERC20OnApproveApproval represents a Approval event raised by the ERC20OnApprove contract. 7267 type ERC20OnApproveApproval struct { 7268 Owner common.Address 7269 Spender common.Address 7270 Value *big.Int 7271 Raw types.Log // Blockchain specific contextual infos 7272 } 7273 7274 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 7275 // 7276 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 7277 func (_ERC20OnApprove *ERC20OnApproveFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20OnApproveApprovalIterator, error) { 7278 7279 var ownerRule []interface{} 7280 for _, ownerItem := range owner { 7281 ownerRule = append(ownerRule, ownerItem) 7282 } 7283 var spenderRule []interface{} 7284 for _, spenderItem := range spender { 7285 spenderRule = append(spenderRule, spenderItem) 7286 } 7287 7288 logs, sub, err := _ERC20OnApprove.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 7289 if err != nil { 7290 return nil, err 7291 } 7292 return &ERC20OnApproveApprovalIterator{contract: _ERC20OnApprove.contract, event: "Approval", logs: logs, sub: sub}, nil 7293 } 7294 7295 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 7296 // 7297 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 7298 func (_ERC20OnApprove *ERC20OnApproveFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20OnApproveApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 7299 7300 var ownerRule []interface{} 7301 for _, ownerItem := range owner { 7302 ownerRule = append(ownerRule, ownerItem) 7303 } 7304 var spenderRule []interface{} 7305 for _, spenderItem := range spender { 7306 spenderRule = append(spenderRule, spenderItem) 7307 } 7308 7309 logs, sub, err := _ERC20OnApprove.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 7310 if err != nil { 7311 return nil, err 7312 } 7313 return event.NewSubscription(func(quit <-chan struct{}) error { 7314 defer sub.Unsubscribe() 7315 for { 7316 select { 7317 case log := <-logs: 7318 // New log arrived, parse the event and forward to the user 7319 event := new(ERC20OnApproveApproval) 7320 if err := _ERC20OnApprove.contract.UnpackLog(event, "Approval", log); err != nil { 7321 return err 7322 } 7323 event.Raw = log 7324 7325 select { 7326 case sink <- event: 7327 case err := <-sub.Err(): 7328 return err 7329 case <-quit: 7330 return nil 7331 } 7332 case err := <-sub.Err(): 7333 return err 7334 case <-quit: 7335 return nil 7336 } 7337 } 7338 }), nil 7339 } 7340 7341 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 7342 // 7343 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 7344 func (_ERC20OnApprove *ERC20OnApproveFilterer) ParseApproval(log types.Log) (*ERC20OnApproveApproval, error) { 7345 event := new(ERC20OnApproveApproval) 7346 if err := _ERC20OnApprove.contract.UnpackLog(event, "Approval", log); err != nil { 7347 return nil, err 7348 } 7349 return event, nil 7350 } 7351 7352 // ERC20OnApproveTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the ERC20OnApprove contract. 7353 type ERC20OnApproveTransferIterator struct { 7354 Event *ERC20OnApproveTransfer // Event containing the contract specifics and raw log 7355 7356 contract *bind.BoundContract // Generic contract to use for unpacking event data 7357 event string // Event name to use for unpacking event data 7358 7359 logs chan types.Log // Log channel receiving the found contract events 7360 sub ethereum.Subscription // Subscription for errors, completion and termination 7361 done bool // Whether the subscription completed delivering logs 7362 fail error // Occurred error to stop iteration 7363 } 7364 7365 // Next advances the iterator to the subsequent event, returning whether there 7366 // are any more events found. In case of a retrieval or parsing error, false is 7367 // returned and Error() can be queried for the exact failure. 7368 func (it *ERC20OnApproveTransferIterator) Next() bool { 7369 // If the iterator failed, stop iterating 7370 if it.fail != nil { 7371 return false 7372 } 7373 // If the iterator completed, deliver directly whatever's available 7374 if it.done { 7375 select { 7376 case log := <-it.logs: 7377 it.Event = new(ERC20OnApproveTransfer) 7378 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 7379 it.fail = err 7380 return false 7381 } 7382 it.Event.Raw = log 7383 return true 7384 7385 default: 7386 return false 7387 } 7388 } 7389 // Iterator still in progress, wait for either a data or an error event 7390 select { 7391 case log := <-it.logs: 7392 it.Event = new(ERC20OnApproveTransfer) 7393 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 7394 it.fail = err 7395 return false 7396 } 7397 it.Event.Raw = log 7398 return true 7399 7400 case err := <-it.sub.Err(): 7401 it.done = true 7402 it.fail = err 7403 return it.Next() 7404 } 7405 } 7406 7407 // Error returns any retrieval or parsing error occurred during filtering. 7408 func (it *ERC20OnApproveTransferIterator) Error() error { 7409 return it.fail 7410 } 7411 7412 // Close terminates the iteration process, releasing any pending underlying 7413 // resources. 7414 func (it *ERC20OnApproveTransferIterator) Close() error { 7415 it.sub.Unsubscribe() 7416 return nil 7417 } 7418 7419 // ERC20OnApproveTransfer represents a Transfer event raised by the ERC20OnApprove contract. 7420 type ERC20OnApproveTransfer struct { 7421 From common.Address 7422 To common.Address 7423 Value *big.Int 7424 Raw types.Log // Blockchain specific contextual infos 7425 } 7426 7427 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 7428 // 7429 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 7430 func (_ERC20OnApprove *ERC20OnApproveFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20OnApproveTransferIterator, error) { 7431 7432 var fromRule []interface{} 7433 for _, fromItem := range from { 7434 fromRule = append(fromRule, fromItem) 7435 } 7436 var toRule []interface{} 7437 for _, toItem := range to { 7438 toRule = append(toRule, toItem) 7439 } 7440 7441 logs, sub, err := _ERC20OnApprove.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 7442 if err != nil { 7443 return nil, err 7444 } 7445 return &ERC20OnApproveTransferIterator{contract: _ERC20OnApprove.contract, event: "Transfer", logs: logs, sub: sub}, nil 7446 } 7447 7448 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 7449 // 7450 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 7451 func (_ERC20OnApprove *ERC20OnApproveFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20OnApproveTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 7452 7453 var fromRule []interface{} 7454 for _, fromItem := range from { 7455 fromRule = append(fromRule, fromItem) 7456 } 7457 var toRule []interface{} 7458 for _, toItem := range to { 7459 toRule = append(toRule, toItem) 7460 } 7461 7462 logs, sub, err := _ERC20OnApprove.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 7463 if err != nil { 7464 return nil, err 7465 } 7466 return event.NewSubscription(func(quit <-chan struct{}) error { 7467 defer sub.Unsubscribe() 7468 for { 7469 select { 7470 case log := <-logs: 7471 // New log arrived, parse the event and forward to the user 7472 event := new(ERC20OnApproveTransfer) 7473 if err := _ERC20OnApprove.contract.UnpackLog(event, "Transfer", log); err != nil { 7474 return err 7475 } 7476 event.Raw = log 7477 7478 select { 7479 case sink <- event: 7480 case err := <-sub.Err(): 7481 return err 7482 case <-quit: 7483 return nil 7484 } 7485 case err := <-sub.Err(): 7486 return err 7487 case <-quit: 7488 return nil 7489 } 7490 } 7491 }), nil 7492 } 7493 7494 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 7495 // 7496 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 7497 func (_ERC20OnApprove *ERC20OnApproveFilterer) ParseTransfer(log types.Log) (*ERC20OnApproveTransfer, error) { 7498 event := new(ERC20OnApproveTransfer) 7499 if err := _ERC20OnApprove.contract.UnpackLog(event, "Transfer", log); err != nil { 7500 return nil, err 7501 } 7502 return event, nil 7503 } 7504 7505 // IERC165ABI is the input ABI used to generate the binding from. 7506 const IERC165ABI = "[{\"constant\":true,\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]" 7507 7508 // IERC165FuncSigs maps the 4-byte function signature to its string representation. 7509 var IERC165FuncSigs = map[string]string{ 7510 "01ffc9a7": "supportsInterface(bytes4)", 7511 } 7512 7513 // IERC165 is an auto generated Go binding around an Ethereum contract. 7514 type IERC165 struct { 7515 IERC165Caller // Read-only binding to the contract 7516 IERC165Transactor // Write-only binding to the contract 7517 IERC165Filterer // Log filterer for contract events 7518 } 7519 7520 // IERC165Caller is an auto generated read-only Go binding around an Ethereum contract. 7521 type IERC165Caller struct { 7522 contract *bind.BoundContract // Generic contract wrapper for the low level calls 7523 } 7524 7525 // IERC165Transactor is an auto generated write-only Go binding around an Ethereum contract. 7526 type IERC165Transactor struct { 7527 contract *bind.BoundContract // Generic contract wrapper for the low level calls 7528 } 7529 7530 // IERC165Filterer is an auto generated log filtering Go binding around an Ethereum contract events. 7531 type IERC165Filterer struct { 7532 contract *bind.BoundContract // Generic contract wrapper for the low level calls 7533 } 7534 7535 // IERC165Session is an auto generated Go binding around an Ethereum contract, 7536 // with pre-set call and transact options. 7537 type IERC165Session struct { 7538 Contract *IERC165 // Generic contract binding to set the session for 7539 CallOpts bind.CallOpts // Call options to use throughout this session 7540 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 7541 } 7542 7543 // IERC165CallerSession is an auto generated read-only Go binding around an Ethereum contract, 7544 // with pre-set call options. 7545 type IERC165CallerSession struct { 7546 Contract *IERC165Caller // Generic contract caller binding to set the session for 7547 CallOpts bind.CallOpts // Call options to use throughout this session 7548 } 7549 7550 // IERC165TransactorSession is an auto generated write-only Go binding around an Ethereum contract, 7551 // with pre-set transact options. 7552 type IERC165TransactorSession struct { 7553 Contract *IERC165Transactor // Generic contract transactor binding to set the session for 7554 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 7555 } 7556 7557 // IERC165Raw is an auto generated low-level Go binding around an Ethereum contract. 7558 type IERC165Raw struct { 7559 Contract *IERC165 // Generic contract binding to access the raw methods on 7560 } 7561 7562 // IERC165CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 7563 type IERC165CallerRaw struct { 7564 Contract *IERC165Caller // Generic read-only contract binding to access the raw methods on 7565 } 7566 7567 // IERC165TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 7568 type IERC165TransactorRaw struct { 7569 Contract *IERC165Transactor // Generic write-only contract binding to access the raw methods on 7570 } 7571 7572 // NewIERC165 creates a new instance of IERC165, bound to a specific deployed contract. 7573 func NewIERC165(address common.Address, backend bind.ContractBackend) (*IERC165, error) { 7574 contract, err := bindIERC165(address, backend, backend, backend) 7575 if err != nil { 7576 return nil, err 7577 } 7578 return &IERC165{IERC165Caller: IERC165Caller{contract: contract}, IERC165Transactor: IERC165Transactor{contract: contract}, IERC165Filterer: IERC165Filterer{contract: contract}}, nil 7579 } 7580 7581 // NewIERC165Caller creates a new read-only instance of IERC165, bound to a specific deployed contract. 7582 func NewIERC165Caller(address common.Address, caller bind.ContractCaller) (*IERC165Caller, error) { 7583 contract, err := bindIERC165(address, caller, nil, nil) 7584 if err != nil { 7585 return nil, err 7586 } 7587 return &IERC165Caller{contract: contract}, nil 7588 } 7589 7590 // NewIERC165Transactor creates a new write-only instance of IERC165, bound to a specific deployed contract. 7591 func NewIERC165Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC165Transactor, error) { 7592 contract, err := bindIERC165(address, nil, transactor, nil) 7593 if err != nil { 7594 return nil, err 7595 } 7596 return &IERC165Transactor{contract: contract}, nil 7597 } 7598 7599 // NewIERC165Filterer creates a new log filterer instance of IERC165, bound to a specific deployed contract. 7600 func NewIERC165Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC165Filterer, error) { 7601 contract, err := bindIERC165(address, nil, nil, filterer) 7602 if err != nil { 7603 return nil, err 7604 } 7605 return &IERC165Filterer{contract: contract}, nil 7606 } 7607 7608 // bindIERC165 binds a generic wrapper to an already deployed contract. 7609 func bindIERC165(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 7610 parsed, err := abi.JSON(strings.NewReader(IERC165ABI)) 7611 if err != nil { 7612 return nil, err 7613 } 7614 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 7615 } 7616 7617 // Call invokes the (constant) contract method with params as input values and 7618 // sets the output to result. The result type might be a single field for simple 7619 // returns, a slice of interfaces for anonymous returns and a struct for named 7620 // returns. 7621 func (_IERC165 *IERC165Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 7622 return _IERC165.Contract.IERC165Caller.contract.Call(opts, result, method, params...) 7623 } 7624 7625 // Transfer initiates a plain transaction to move funds to the contract, calling 7626 // its default method if one is available. 7627 func (_IERC165 *IERC165Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 7628 return _IERC165.Contract.IERC165Transactor.contract.Transfer(opts) 7629 } 7630 7631 // Transact invokes the (paid) contract method with params as input values. 7632 func (_IERC165 *IERC165Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 7633 return _IERC165.Contract.IERC165Transactor.contract.Transact(opts, method, params...) 7634 } 7635 7636 // Call invokes the (constant) contract method with params as input values and 7637 // sets the output to result. The result type might be a single field for simple 7638 // returns, a slice of interfaces for anonymous returns and a struct for named 7639 // returns. 7640 func (_IERC165 *IERC165CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 7641 return _IERC165.Contract.contract.Call(opts, result, method, params...) 7642 } 7643 7644 // Transfer initiates a plain transaction to move funds to the contract, calling 7645 // its default method if one is available. 7646 func (_IERC165 *IERC165TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 7647 return _IERC165.Contract.contract.Transfer(opts) 7648 } 7649 7650 // Transact invokes the (paid) contract method with params as input values. 7651 func (_IERC165 *IERC165TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 7652 return _IERC165.Contract.contract.Transact(opts, method, params...) 7653 } 7654 7655 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 7656 // 7657 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 7658 func (_IERC165 *IERC165Caller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { 7659 var ( 7660 ret0 = new(bool) 7661 ) 7662 out := ret0 7663 err := _IERC165.contract.Call(opts, out, "supportsInterface", interfaceId) 7664 return *ret0, err 7665 } 7666 7667 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 7668 // 7669 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 7670 func (_IERC165 *IERC165Session) SupportsInterface(interfaceId [4]byte) (bool, error) { 7671 return _IERC165.Contract.SupportsInterface(&_IERC165.CallOpts, interfaceId) 7672 } 7673 7674 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 7675 // 7676 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 7677 func (_IERC165 *IERC165CallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { 7678 return _IERC165.Contract.SupportsInterface(&_IERC165.CallOpts, interfaceId) 7679 } 7680 7681 // IERC20ABI is the input ABI used to generate the binding from. 7682 const IERC20ABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"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\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 7683 7684 // IERC20FuncSigs maps the 4-byte function signature to its string representation. 7685 var IERC20FuncSigs = map[string]string{ 7686 "dd62ed3e": "allowance(address,address)", 7687 "095ea7b3": "approve(address,uint256)", 7688 "70a08231": "balanceOf(address)", 7689 "18160ddd": "totalSupply()", 7690 "a9059cbb": "transfer(address,uint256)", 7691 "23b872dd": "transferFrom(address,address,uint256)", 7692 } 7693 7694 // IERC20 is an auto generated Go binding around an Ethereum contract. 7695 type IERC20 struct { 7696 IERC20Caller // Read-only binding to the contract 7697 IERC20Transactor // Write-only binding to the contract 7698 IERC20Filterer // Log filterer for contract events 7699 } 7700 7701 // IERC20Caller is an auto generated read-only Go binding around an Ethereum contract. 7702 type IERC20Caller struct { 7703 contract *bind.BoundContract // Generic contract wrapper for the low level calls 7704 } 7705 7706 // IERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. 7707 type IERC20Transactor struct { 7708 contract *bind.BoundContract // Generic contract wrapper for the low level calls 7709 } 7710 7711 // IERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. 7712 type IERC20Filterer struct { 7713 contract *bind.BoundContract // Generic contract wrapper for the low level calls 7714 } 7715 7716 // IERC20Session is an auto generated Go binding around an Ethereum contract, 7717 // with pre-set call and transact options. 7718 type IERC20Session struct { 7719 Contract *IERC20 // Generic contract binding to set the session for 7720 CallOpts bind.CallOpts // Call options to use throughout this session 7721 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 7722 } 7723 7724 // IERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, 7725 // with pre-set call options. 7726 type IERC20CallerSession struct { 7727 Contract *IERC20Caller // Generic contract caller binding to set the session for 7728 CallOpts bind.CallOpts // Call options to use throughout this session 7729 } 7730 7731 // IERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, 7732 // with pre-set transact options. 7733 type IERC20TransactorSession struct { 7734 Contract *IERC20Transactor // Generic contract transactor binding to set the session for 7735 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 7736 } 7737 7738 // IERC20Raw is an auto generated low-level Go binding around an Ethereum contract. 7739 type IERC20Raw struct { 7740 Contract *IERC20 // Generic contract binding to access the raw methods on 7741 } 7742 7743 // IERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 7744 type IERC20CallerRaw struct { 7745 Contract *IERC20Caller // Generic read-only contract binding to access the raw methods on 7746 } 7747 7748 // IERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 7749 type IERC20TransactorRaw struct { 7750 Contract *IERC20Transactor // Generic write-only contract binding to access the raw methods on 7751 } 7752 7753 // NewIERC20 creates a new instance of IERC20, bound to a specific deployed contract. 7754 func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error) { 7755 contract, err := bindIERC20(address, backend, backend, backend) 7756 if err != nil { 7757 return nil, err 7758 } 7759 return &IERC20{IERC20Caller: IERC20Caller{contract: contract}, IERC20Transactor: IERC20Transactor{contract: contract}, IERC20Filterer: IERC20Filterer{contract: contract}}, nil 7760 } 7761 7762 // NewIERC20Caller creates a new read-only instance of IERC20, bound to a specific deployed contract. 7763 func NewIERC20Caller(address common.Address, caller bind.ContractCaller) (*IERC20Caller, error) { 7764 contract, err := bindIERC20(address, caller, nil, nil) 7765 if err != nil { 7766 return nil, err 7767 } 7768 return &IERC20Caller{contract: contract}, nil 7769 } 7770 7771 // NewIERC20Transactor creates a new write-only instance of IERC20, bound to a specific deployed contract. 7772 func NewIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC20Transactor, error) { 7773 contract, err := bindIERC20(address, nil, transactor, nil) 7774 if err != nil { 7775 return nil, err 7776 } 7777 return &IERC20Transactor{contract: contract}, nil 7778 } 7779 7780 // NewIERC20Filterer creates a new log filterer instance of IERC20, bound to a specific deployed contract. 7781 func NewIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC20Filterer, error) { 7782 contract, err := bindIERC20(address, nil, nil, filterer) 7783 if err != nil { 7784 return nil, err 7785 } 7786 return &IERC20Filterer{contract: contract}, nil 7787 } 7788 7789 // bindIERC20 binds a generic wrapper to an already deployed contract. 7790 func bindIERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 7791 parsed, err := abi.JSON(strings.NewReader(IERC20ABI)) 7792 if err != nil { 7793 return nil, err 7794 } 7795 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 7796 } 7797 7798 // Call invokes the (constant) contract method with params as input values and 7799 // sets the output to result. The result type might be a single field for simple 7800 // returns, a slice of interfaces for anonymous returns and a struct for named 7801 // returns. 7802 func (_IERC20 *IERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 7803 return _IERC20.Contract.IERC20Caller.contract.Call(opts, result, method, params...) 7804 } 7805 7806 // Transfer initiates a plain transaction to move funds to the contract, calling 7807 // its default method if one is available. 7808 func (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 7809 return _IERC20.Contract.IERC20Transactor.contract.Transfer(opts) 7810 } 7811 7812 // Transact invokes the (paid) contract method with params as input values. 7813 func (_IERC20 *IERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 7814 return _IERC20.Contract.IERC20Transactor.contract.Transact(opts, method, params...) 7815 } 7816 7817 // Call invokes the (constant) contract method with params as input values and 7818 // sets the output to result. The result type might be a single field for simple 7819 // returns, a slice of interfaces for anonymous returns and a struct for named 7820 // returns. 7821 func (_IERC20 *IERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 7822 return _IERC20.Contract.contract.Call(opts, result, method, params...) 7823 } 7824 7825 // Transfer initiates a plain transaction to move funds to the contract, calling 7826 // its default method if one is available. 7827 func (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 7828 return _IERC20.Contract.contract.Transfer(opts) 7829 } 7830 7831 // Transact invokes the (paid) contract method with params as input values. 7832 func (_IERC20 *IERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 7833 return _IERC20.Contract.contract.Transact(opts, method, params...) 7834 } 7835 7836 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 7837 // 7838 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 7839 func (_IERC20 *IERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 7840 var ( 7841 ret0 = new(*big.Int) 7842 ) 7843 out := ret0 7844 err := _IERC20.contract.Call(opts, out, "allowance", owner, spender) 7845 return *ret0, err 7846 } 7847 7848 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 7849 // 7850 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 7851 func (_IERC20 *IERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 7852 return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender) 7853 } 7854 7855 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 7856 // 7857 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 7858 func (_IERC20 *IERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 7859 return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender) 7860 } 7861 7862 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 7863 // 7864 // Solidity: function balanceOf(address account) constant returns(uint256) 7865 func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 7866 var ( 7867 ret0 = new(*big.Int) 7868 ) 7869 out := ret0 7870 err := _IERC20.contract.Call(opts, out, "balanceOf", account) 7871 return *ret0, err 7872 } 7873 7874 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 7875 // 7876 // Solidity: function balanceOf(address account) constant returns(uint256) 7877 func (_IERC20 *IERC20Session) BalanceOf(account common.Address) (*big.Int, error) { 7878 return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account) 7879 } 7880 7881 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 7882 // 7883 // Solidity: function balanceOf(address account) constant returns(uint256) 7884 func (_IERC20 *IERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { 7885 return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account) 7886 } 7887 7888 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 7889 // 7890 // Solidity: function totalSupply() constant returns(uint256) 7891 func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 7892 var ( 7893 ret0 = new(*big.Int) 7894 ) 7895 out := ret0 7896 err := _IERC20.contract.Call(opts, out, "totalSupply") 7897 return *ret0, err 7898 } 7899 7900 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 7901 // 7902 // Solidity: function totalSupply() constant returns(uint256) 7903 func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error) { 7904 return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts) 7905 } 7906 7907 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 7908 // 7909 // Solidity: function totalSupply() constant returns(uint256) 7910 func (_IERC20 *IERC20CallerSession) TotalSupply() (*big.Int, error) { 7911 return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts) 7912 } 7913 7914 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 7915 // 7916 // Solidity: function approve(address spender, uint256 amount) returns(bool) 7917 func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 7918 return _IERC20.contract.Transact(opts, "approve", spender, amount) 7919 } 7920 7921 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 7922 // 7923 // Solidity: function approve(address spender, uint256 amount) returns(bool) 7924 func (_IERC20 *IERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 7925 return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount) 7926 } 7927 7928 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 7929 // 7930 // Solidity: function approve(address spender, uint256 amount) returns(bool) 7931 func (_IERC20 *IERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 7932 return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount) 7933 } 7934 7935 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 7936 // 7937 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 7938 func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7939 return _IERC20.contract.Transact(opts, "transfer", recipient, amount) 7940 } 7941 7942 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 7943 // 7944 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 7945 func (_IERC20 *IERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7946 return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, recipient, amount) 7947 } 7948 7949 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 7950 // 7951 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 7952 func (_IERC20 *IERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7953 return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, recipient, amount) 7954 } 7955 7956 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 7957 // 7958 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 7959 func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7960 return _IERC20.contract.Transact(opts, "transferFrom", sender, recipient, amount) 7961 } 7962 7963 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 7964 // 7965 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 7966 func (_IERC20 *IERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7967 return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, sender, recipient, amount) 7968 } 7969 7970 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 7971 // 7972 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 7973 func (_IERC20 *IERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7974 return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, sender, recipient, amount) 7975 } 7976 7977 // IERC20ApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the IERC20 contract. 7978 type IERC20ApprovalIterator struct { 7979 Event *IERC20Approval // Event containing the contract specifics and raw log 7980 7981 contract *bind.BoundContract // Generic contract to use for unpacking event data 7982 event string // Event name to use for unpacking event data 7983 7984 logs chan types.Log // Log channel receiving the found contract events 7985 sub ethereum.Subscription // Subscription for errors, completion and termination 7986 done bool // Whether the subscription completed delivering logs 7987 fail error // Occurred error to stop iteration 7988 } 7989 7990 // Next advances the iterator to the subsequent event, returning whether there 7991 // are any more events found. In case of a retrieval or parsing error, false is 7992 // returned and Error() can be queried for the exact failure. 7993 func (it *IERC20ApprovalIterator) Next() bool { 7994 // If the iterator failed, stop iterating 7995 if it.fail != nil { 7996 return false 7997 } 7998 // If the iterator completed, deliver directly whatever's available 7999 if it.done { 8000 select { 8001 case log := <-it.logs: 8002 it.Event = new(IERC20Approval) 8003 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 8004 it.fail = err 8005 return false 8006 } 8007 it.Event.Raw = log 8008 return true 8009 8010 default: 8011 return false 8012 } 8013 } 8014 // Iterator still in progress, wait for either a data or an error event 8015 select { 8016 case log := <-it.logs: 8017 it.Event = new(IERC20Approval) 8018 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 8019 it.fail = err 8020 return false 8021 } 8022 it.Event.Raw = log 8023 return true 8024 8025 case err := <-it.sub.Err(): 8026 it.done = true 8027 it.fail = err 8028 return it.Next() 8029 } 8030 } 8031 8032 // Error returns any retrieval or parsing error occurred during filtering. 8033 func (it *IERC20ApprovalIterator) Error() error { 8034 return it.fail 8035 } 8036 8037 // Close terminates the iteration process, releasing any pending underlying 8038 // resources. 8039 func (it *IERC20ApprovalIterator) Close() error { 8040 it.sub.Unsubscribe() 8041 return nil 8042 } 8043 8044 // IERC20Approval represents a Approval event raised by the IERC20 contract. 8045 type IERC20Approval struct { 8046 Owner common.Address 8047 Spender common.Address 8048 Value *big.Int 8049 Raw types.Log // Blockchain specific contextual infos 8050 } 8051 8052 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 8053 // 8054 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 8055 func (_IERC20 *IERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20ApprovalIterator, error) { 8056 8057 var ownerRule []interface{} 8058 for _, ownerItem := range owner { 8059 ownerRule = append(ownerRule, ownerItem) 8060 } 8061 var spenderRule []interface{} 8062 for _, spenderItem := range spender { 8063 spenderRule = append(spenderRule, spenderItem) 8064 } 8065 8066 logs, sub, err := _IERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 8067 if err != nil { 8068 return nil, err 8069 } 8070 return &IERC20ApprovalIterator{contract: _IERC20.contract, event: "Approval", logs: logs, sub: sub}, nil 8071 } 8072 8073 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 8074 // 8075 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 8076 func (_IERC20 *IERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 8077 8078 var ownerRule []interface{} 8079 for _, ownerItem := range owner { 8080 ownerRule = append(ownerRule, ownerItem) 8081 } 8082 var spenderRule []interface{} 8083 for _, spenderItem := range spender { 8084 spenderRule = append(spenderRule, spenderItem) 8085 } 8086 8087 logs, sub, err := _IERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 8088 if err != nil { 8089 return nil, err 8090 } 8091 return event.NewSubscription(func(quit <-chan struct{}) error { 8092 defer sub.Unsubscribe() 8093 for { 8094 select { 8095 case log := <-logs: 8096 // New log arrived, parse the event and forward to the user 8097 event := new(IERC20Approval) 8098 if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil { 8099 return err 8100 } 8101 event.Raw = log 8102 8103 select { 8104 case sink <- event: 8105 case err := <-sub.Err(): 8106 return err 8107 case <-quit: 8108 return nil 8109 } 8110 case err := <-sub.Err(): 8111 return err 8112 case <-quit: 8113 return nil 8114 } 8115 } 8116 }), nil 8117 } 8118 8119 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 8120 // 8121 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 8122 func (_IERC20 *IERC20Filterer) ParseApproval(log types.Log) (*IERC20Approval, error) { 8123 event := new(IERC20Approval) 8124 if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil { 8125 return nil, err 8126 } 8127 return event, nil 8128 } 8129 8130 // IERC20TransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the IERC20 contract. 8131 type IERC20TransferIterator struct { 8132 Event *IERC20Transfer // Event containing the contract specifics and raw log 8133 8134 contract *bind.BoundContract // Generic contract to use for unpacking event data 8135 event string // Event name to use for unpacking event data 8136 8137 logs chan types.Log // Log channel receiving the found contract events 8138 sub ethereum.Subscription // Subscription for errors, completion and termination 8139 done bool // Whether the subscription completed delivering logs 8140 fail error // Occurred error to stop iteration 8141 } 8142 8143 // Next advances the iterator to the subsequent event, returning whether there 8144 // are any more events found. In case of a retrieval or parsing error, false is 8145 // returned and Error() can be queried for the exact failure. 8146 func (it *IERC20TransferIterator) Next() bool { 8147 // If the iterator failed, stop iterating 8148 if it.fail != nil { 8149 return false 8150 } 8151 // If the iterator completed, deliver directly whatever's available 8152 if it.done { 8153 select { 8154 case log := <-it.logs: 8155 it.Event = new(IERC20Transfer) 8156 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 8157 it.fail = err 8158 return false 8159 } 8160 it.Event.Raw = log 8161 return true 8162 8163 default: 8164 return false 8165 } 8166 } 8167 // Iterator still in progress, wait for either a data or an error event 8168 select { 8169 case log := <-it.logs: 8170 it.Event = new(IERC20Transfer) 8171 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 8172 it.fail = err 8173 return false 8174 } 8175 it.Event.Raw = log 8176 return true 8177 8178 case err := <-it.sub.Err(): 8179 it.done = true 8180 it.fail = err 8181 return it.Next() 8182 } 8183 } 8184 8185 // Error returns any retrieval or parsing error occurred during filtering. 8186 func (it *IERC20TransferIterator) Error() error { 8187 return it.fail 8188 } 8189 8190 // Close terminates the iteration process, releasing any pending underlying 8191 // resources. 8192 func (it *IERC20TransferIterator) Close() error { 8193 it.sub.Unsubscribe() 8194 return nil 8195 } 8196 8197 // IERC20Transfer represents a Transfer event raised by the IERC20 contract. 8198 type IERC20Transfer struct { 8199 From common.Address 8200 To common.Address 8201 Value *big.Int 8202 Raw types.Log // Blockchain specific contextual infos 8203 } 8204 8205 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 8206 // 8207 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 8208 func (_IERC20 *IERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20TransferIterator, error) { 8209 8210 var fromRule []interface{} 8211 for _, fromItem := range from { 8212 fromRule = append(fromRule, fromItem) 8213 } 8214 var toRule []interface{} 8215 for _, toItem := range to { 8216 toRule = append(toRule, toItem) 8217 } 8218 8219 logs, sub, err := _IERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 8220 if err != nil { 8221 return nil, err 8222 } 8223 return &IERC20TransferIterator{contract: _IERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil 8224 } 8225 8226 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 8227 // 8228 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 8229 func (_IERC20 *IERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { 8230 8231 var fromRule []interface{} 8232 for _, fromItem := range from { 8233 fromRule = append(fromRule, fromItem) 8234 } 8235 var toRule []interface{} 8236 for _, toItem := range to { 8237 toRule = append(toRule, toItem) 8238 } 8239 8240 logs, sub, err := _IERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 8241 if err != nil { 8242 return nil, err 8243 } 8244 return event.NewSubscription(func(quit <-chan struct{}) error { 8245 defer sub.Unsubscribe() 8246 for { 8247 select { 8248 case log := <-logs: 8249 // New log arrived, parse the event and forward to the user 8250 event := new(IERC20Transfer) 8251 if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil { 8252 return err 8253 } 8254 event.Raw = log 8255 8256 select { 8257 case sink <- event: 8258 case err := <-sub.Err(): 8259 return err 8260 case <-quit: 8261 return nil 8262 } 8263 case err := <-sub.Err(): 8264 return err 8265 case <-quit: 8266 return nil 8267 } 8268 } 8269 }), nil 8270 } 8271 8272 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 8273 // 8274 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 8275 func (_IERC20 *IERC20Filterer) ParseTransfer(log types.Log) (*IERC20Transfer, error) { 8276 event := new(IERC20Transfer) 8277 if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil { 8278 return nil, err 8279 } 8280 return event, nil 8281 } 8282 8283 // MinterRoleABI is the input ABI used to generate the binding from. 8284 const MinterRoleABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterRemoved\",\"type\":\"event\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isMinter\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 8285 8286 // MinterRoleFuncSigs maps the 4-byte function signature to its string representation. 8287 var MinterRoleFuncSigs = map[string]string{ 8288 "983b2d56": "addMinter(address)", 8289 "aa271e1a": "isMinter(address)", 8290 "98650275": "renounceMinter()", 8291 } 8292 8293 // MinterRole is an auto generated Go binding around an Ethereum contract. 8294 type MinterRole struct { 8295 MinterRoleCaller // Read-only binding to the contract 8296 MinterRoleTransactor // Write-only binding to the contract 8297 MinterRoleFilterer // Log filterer for contract events 8298 } 8299 8300 // MinterRoleCaller is an auto generated read-only Go binding around an Ethereum contract. 8301 type MinterRoleCaller struct { 8302 contract *bind.BoundContract // Generic contract wrapper for the low level calls 8303 } 8304 8305 // MinterRoleTransactor is an auto generated write-only Go binding around an Ethereum contract. 8306 type MinterRoleTransactor struct { 8307 contract *bind.BoundContract // Generic contract wrapper for the low level calls 8308 } 8309 8310 // MinterRoleFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 8311 type MinterRoleFilterer struct { 8312 contract *bind.BoundContract // Generic contract wrapper for the low level calls 8313 } 8314 8315 // MinterRoleSession is an auto generated Go binding around an Ethereum contract, 8316 // with pre-set call and transact options. 8317 type MinterRoleSession struct { 8318 Contract *MinterRole // Generic contract binding to set the session for 8319 CallOpts bind.CallOpts // Call options to use throughout this session 8320 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 8321 } 8322 8323 // MinterRoleCallerSession is an auto generated read-only Go binding around an Ethereum contract, 8324 // with pre-set call options. 8325 type MinterRoleCallerSession struct { 8326 Contract *MinterRoleCaller // Generic contract caller binding to set the session for 8327 CallOpts bind.CallOpts // Call options to use throughout this session 8328 } 8329 8330 // MinterRoleTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 8331 // with pre-set transact options. 8332 type MinterRoleTransactorSession struct { 8333 Contract *MinterRoleTransactor // Generic contract transactor binding to set the session for 8334 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 8335 } 8336 8337 // MinterRoleRaw is an auto generated low-level Go binding around an Ethereum contract. 8338 type MinterRoleRaw struct { 8339 Contract *MinterRole // Generic contract binding to access the raw methods on 8340 } 8341 8342 // MinterRoleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 8343 type MinterRoleCallerRaw struct { 8344 Contract *MinterRoleCaller // Generic read-only contract binding to access the raw methods on 8345 } 8346 8347 // MinterRoleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 8348 type MinterRoleTransactorRaw struct { 8349 Contract *MinterRoleTransactor // Generic write-only contract binding to access the raw methods on 8350 } 8351 8352 // NewMinterRole creates a new instance of MinterRole, bound to a specific deployed contract. 8353 func NewMinterRole(address common.Address, backend bind.ContractBackend) (*MinterRole, error) { 8354 contract, err := bindMinterRole(address, backend, backend, backend) 8355 if err != nil { 8356 return nil, err 8357 } 8358 return &MinterRole{MinterRoleCaller: MinterRoleCaller{contract: contract}, MinterRoleTransactor: MinterRoleTransactor{contract: contract}, MinterRoleFilterer: MinterRoleFilterer{contract: contract}}, nil 8359 } 8360 8361 // NewMinterRoleCaller creates a new read-only instance of MinterRole, bound to a specific deployed contract. 8362 func NewMinterRoleCaller(address common.Address, caller bind.ContractCaller) (*MinterRoleCaller, error) { 8363 contract, err := bindMinterRole(address, caller, nil, nil) 8364 if err != nil { 8365 return nil, err 8366 } 8367 return &MinterRoleCaller{contract: contract}, nil 8368 } 8369 8370 // NewMinterRoleTransactor creates a new write-only instance of MinterRole, bound to a specific deployed contract. 8371 func NewMinterRoleTransactor(address common.Address, transactor bind.ContractTransactor) (*MinterRoleTransactor, error) { 8372 contract, err := bindMinterRole(address, nil, transactor, nil) 8373 if err != nil { 8374 return nil, err 8375 } 8376 return &MinterRoleTransactor{contract: contract}, nil 8377 } 8378 8379 // NewMinterRoleFilterer creates a new log filterer instance of MinterRole, bound to a specific deployed contract. 8380 func NewMinterRoleFilterer(address common.Address, filterer bind.ContractFilterer) (*MinterRoleFilterer, error) { 8381 contract, err := bindMinterRole(address, nil, nil, filterer) 8382 if err != nil { 8383 return nil, err 8384 } 8385 return &MinterRoleFilterer{contract: contract}, nil 8386 } 8387 8388 // bindMinterRole binds a generic wrapper to an already deployed contract. 8389 func bindMinterRole(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 8390 parsed, err := abi.JSON(strings.NewReader(MinterRoleABI)) 8391 if err != nil { 8392 return nil, err 8393 } 8394 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 8395 } 8396 8397 // Call invokes the (constant) contract method with params as input values and 8398 // sets the output to result. The result type might be a single field for simple 8399 // returns, a slice of interfaces for anonymous returns and a struct for named 8400 // returns. 8401 func (_MinterRole *MinterRoleRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 8402 return _MinterRole.Contract.MinterRoleCaller.contract.Call(opts, result, method, params...) 8403 } 8404 8405 // Transfer initiates a plain transaction to move funds to the contract, calling 8406 // its default method if one is available. 8407 func (_MinterRole *MinterRoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 8408 return _MinterRole.Contract.MinterRoleTransactor.contract.Transfer(opts) 8409 } 8410 8411 // Transact invokes the (paid) contract method with params as input values. 8412 func (_MinterRole *MinterRoleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 8413 return _MinterRole.Contract.MinterRoleTransactor.contract.Transact(opts, method, params...) 8414 } 8415 8416 // Call invokes the (constant) contract method with params as input values and 8417 // sets the output to result. The result type might be a single field for simple 8418 // returns, a slice of interfaces for anonymous returns and a struct for named 8419 // returns. 8420 func (_MinterRole *MinterRoleCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 8421 return _MinterRole.Contract.contract.Call(opts, result, method, params...) 8422 } 8423 8424 // Transfer initiates a plain transaction to move funds to the contract, calling 8425 // its default method if one is available. 8426 func (_MinterRole *MinterRoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 8427 return _MinterRole.Contract.contract.Transfer(opts) 8428 } 8429 8430 // Transact invokes the (paid) contract method with params as input values. 8431 func (_MinterRole *MinterRoleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 8432 return _MinterRole.Contract.contract.Transact(opts, method, params...) 8433 } 8434 8435 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 8436 // 8437 // Solidity: function isMinter(address account) constant returns(bool) 8438 func (_MinterRole *MinterRoleCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) { 8439 var ( 8440 ret0 = new(bool) 8441 ) 8442 out := ret0 8443 err := _MinterRole.contract.Call(opts, out, "isMinter", account) 8444 return *ret0, err 8445 } 8446 8447 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 8448 // 8449 // Solidity: function isMinter(address account) constant returns(bool) 8450 func (_MinterRole *MinterRoleSession) IsMinter(account common.Address) (bool, error) { 8451 return _MinterRole.Contract.IsMinter(&_MinterRole.CallOpts, account) 8452 } 8453 8454 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 8455 // 8456 // Solidity: function isMinter(address account) constant returns(bool) 8457 func (_MinterRole *MinterRoleCallerSession) IsMinter(account common.Address) (bool, error) { 8458 return _MinterRole.Contract.IsMinter(&_MinterRole.CallOpts, account) 8459 } 8460 8461 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 8462 // 8463 // Solidity: function addMinter(address account) returns() 8464 func (_MinterRole *MinterRoleTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) { 8465 return _MinterRole.contract.Transact(opts, "addMinter", account) 8466 } 8467 8468 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 8469 // 8470 // Solidity: function addMinter(address account) returns() 8471 func (_MinterRole *MinterRoleSession) AddMinter(account common.Address) (*types.Transaction, error) { 8472 return _MinterRole.Contract.AddMinter(&_MinterRole.TransactOpts, account) 8473 } 8474 8475 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 8476 // 8477 // Solidity: function addMinter(address account) returns() 8478 func (_MinterRole *MinterRoleTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) { 8479 return _MinterRole.Contract.AddMinter(&_MinterRole.TransactOpts, account) 8480 } 8481 8482 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 8483 // 8484 // Solidity: function renounceMinter() returns() 8485 func (_MinterRole *MinterRoleTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) { 8486 return _MinterRole.contract.Transact(opts, "renounceMinter") 8487 } 8488 8489 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 8490 // 8491 // Solidity: function renounceMinter() returns() 8492 func (_MinterRole *MinterRoleSession) RenounceMinter() (*types.Transaction, error) { 8493 return _MinterRole.Contract.RenounceMinter(&_MinterRole.TransactOpts) 8494 } 8495 8496 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 8497 // 8498 // Solidity: function renounceMinter() returns() 8499 func (_MinterRole *MinterRoleTransactorSession) RenounceMinter() (*types.Transaction, error) { 8500 return _MinterRole.Contract.RenounceMinter(&_MinterRole.TransactOpts) 8501 } 8502 8503 // MinterRoleMinterAddedIterator is returned from FilterMinterAdded and is used to iterate over the raw logs and unpacked data for MinterAdded events raised by the MinterRole contract. 8504 type MinterRoleMinterAddedIterator struct { 8505 Event *MinterRoleMinterAdded // Event containing the contract specifics and raw log 8506 8507 contract *bind.BoundContract // Generic contract to use for unpacking event data 8508 event string // Event name to use for unpacking event data 8509 8510 logs chan types.Log // Log channel receiving the found contract events 8511 sub ethereum.Subscription // Subscription for errors, completion and termination 8512 done bool // Whether the subscription completed delivering logs 8513 fail error // Occurred error to stop iteration 8514 } 8515 8516 // Next advances the iterator to the subsequent event, returning whether there 8517 // are any more events found. In case of a retrieval or parsing error, false is 8518 // returned and Error() can be queried for the exact failure. 8519 func (it *MinterRoleMinterAddedIterator) Next() bool { 8520 // If the iterator failed, stop iterating 8521 if it.fail != nil { 8522 return false 8523 } 8524 // If the iterator completed, deliver directly whatever's available 8525 if it.done { 8526 select { 8527 case log := <-it.logs: 8528 it.Event = new(MinterRoleMinterAdded) 8529 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 8530 it.fail = err 8531 return false 8532 } 8533 it.Event.Raw = log 8534 return true 8535 8536 default: 8537 return false 8538 } 8539 } 8540 // Iterator still in progress, wait for either a data or an error event 8541 select { 8542 case log := <-it.logs: 8543 it.Event = new(MinterRoleMinterAdded) 8544 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 8545 it.fail = err 8546 return false 8547 } 8548 it.Event.Raw = log 8549 return true 8550 8551 case err := <-it.sub.Err(): 8552 it.done = true 8553 it.fail = err 8554 return it.Next() 8555 } 8556 } 8557 8558 // Error returns any retrieval or parsing error occurred during filtering. 8559 func (it *MinterRoleMinterAddedIterator) Error() error { 8560 return it.fail 8561 } 8562 8563 // Close terminates the iteration process, releasing any pending underlying 8564 // resources. 8565 func (it *MinterRoleMinterAddedIterator) Close() error { 8566 it.sub.Unsubscribe() 8567 return nil 8568 } 8569 8570 // MinterRoleMinterAdded represents a MinterAdded event raised by the MinterRole contract. 8571 type MinterRoleMinterAdded struct { 8572 Account common.Address 8573 Raw types.Log // Blockchain specific contextual infos 8574 } 8575 8576 // FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 8577 // 8578 // Solidity: event MinterAdded(address indexed account) 8579 func (_MinterRole *MinterRoleFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterAddedIterator, error) { 8580 8581 var accountRule []interface{} 8582 for _, accountItem := range account { 8583 accountRule = append(accountRule, accountItem) 8584 } 8585 8586 logs, sub, err := _MinterRole.contract.FilterLogs(opts, "MinterAdded", accountRule) 8587 if err != nil { 8588 return nil, err 8589 } 8590 return &MinterRoleMinterAddedIterator{contract: _MinterRole.contract, event: "MinterAdded", logs: logs, sub: sub}, nil 8591 } 8592 8593 // WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 8594 // 8595 // Solidity: event MinterAdded(address indexed account) 8596 func (_MinterRole *MinterRoleFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterAdded, account []common.Address) (event.Subscription, error) { 8597 8598 var accountRule []interface{} 8599 for _, accountItem := range account { 8600 accountRule = append(accountRule, accountItem) 8601 } 8602 8603 logs, sub, err := _MinterRole.contract.WatchLogs(opts, "MinterAdded", accountRule) 8604 if err != nil { 8605 return nil, err 8606 } 8607 return event.NewSubscription(func(quit <-chan struct{}) error { 8608 defer sub.Unsubscribe() 8609 for { 8610 select { 8611 case log := <-logs: 8612 // New log arrived, parse the event and forward to the user 8613 event := new(MinterRoleMinterAdded) 8614 if err := _MinterRole.contract.UnpackLog(event, "MinterAdded", log); err != nil { 8615 return err 8616 } 8617 event.Raw = log 8618 8619 select { 8620 case sink <- event: 8621 case err := <-sub.Err(): 8622 return err 8623 case <-quit: 8624 return nil 8625 } 8626 case err := <-sub.Err(): 8627 return err 8628 case <-quit: 8629 return nil 8630 } 8631 } 8632 }), nil 8633 } 8634 8635 // ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 8636 // 8637 // Solidity: event MinterAdded(address indexed account) 8638 func (_MinterRole *MinterRoleFilterer) ParseMinterAdded(log types.Log) (*MinterRoleMinterAdded, error) { 8639 event := new(MinterRoleMinterAdded) 8640 if err := _MinterRole.contract.UnpackLog(event, "MinterAdded", log); err != nil { 8641 return nil, err 8642 } 8643 return event, nil 8644 } 8645 8646 // MinterRoleMinterRemovedIterator is returned from FilterMinterRemoved and is used to iterate over the raw logs and unpacked data for MinterRemoved events raised by the MinterRole contract. 8647 type MinterRoleMinterRemovedIterator struct { 8648 Event *MinterRoleMinterRemoved // Event containing the contract specifics and raw log 8649 8650 contract *bind.BoundContract // Generic contract to use for unpacking event data 8651 event string // Event name to use for unpacking event data 8652 8653 logs chan types.Log // Log channel receiving the found contract events 8654 sub ethereum.Subscription // Subscription for errors, completion and termination 8655 done bool // Whether the subscription completed delivering logs 8656 fail error // Occurred error to stop iteration 8657 } 8658 8659 // Next advances the iterator to the subsequent event, returning whether there 8660 // are any more events found. In case of a retrieval or parsing error, false is 8661 // returned and Error() can be queried for the exact failure. 8662 func (it *MinterRoleMinterRemovedIterator) Next() bool { 8663 // If the iterator failed, stop iterating 8664 if it.fail != nil { 8665 return false 8666 } 8667 // If the iterator completed, deliver directly whatever's available 8668 if it.done { 8669 select { 8670 case log := <-it.logs: 8671 it.Event = new(MinterRoleMinterRemoved) 8672 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 8673 it.fail = err 8674 return false 8675 } 8676 it.Event.Raw = log 8677 return true 8678 8679 default: 8680 return false 8681 } 8682 } 8683 // Iterator still in progress, wait for either a data or an error event 8684 select { 8685 case log := <-it.logs: 8686 it.Event = new(MinterRoleMinterRemoved) 8687 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 8688 it.fail = err 8689 return false 8690 } 8691 it.Event.Raw = log 8692 return true 8693 8694 case err := <-it.sub.Err(): 8695 it.done = true 8696 it.fail = err 8697 return it.Next() 8698 } 8699 } 8700 8701 // Error returns any retrieval or parsing error occurred during filtering. 8702 func (it *MinterRoleMinterRemovedIterator) Error() error { 8703 return it.fail 8704 } 8705 8706 // Close terminates the iteration process, releasing any pending underlying 8707 // resources. 8708 func (it *MinterRoleMinterRemovedIterator) Close() error { 8709 it.sub.Unsubscribe() 8710 return nil 8711 } 8712 8713 // MinterRoleMinterRemoved represents a MinterRemoved event raised by the MinterRole contract. 8714 type MinterRoleMinterRemoved struct { 8715 Account common.Address 8716 Raw types.Log // Blockchain specific contextual infos 8717 } 8718 8719 // FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 8720 // 8721 // Solidity: event MinterRemoved(address indexed account) 8722 func (_MinterRole *MinterRoleFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterRemovedIterator, error) { 8723 8724 var accountRule []interface{} 8725 for _, accountItem := range account { 8726 accountRule = append(accountRule, accountItem) 8727 } 8728 8729 logs, sub, err := _MinterRole.contract.FilterLogs(opts, "MinterRemoved", accountRule) 8730 if err != nil { 8731 return nil, err 8732 } 8733 return &MinterRoleMinterRemovedIterator{contract: _MinterRole.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil 8734 } 8735 8736 // WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 8737 // 8738 // Solidity: event MinterRemoved(address indexed account) 8739 func (_MinterRole *MinterRoleFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterRemoved, account []common.Address) (event.Subscription, error) { 8740 8741 var accountRule []interface{} 8742 for _, accountItem := range account { 8743 accountRule = append(accountRule, accountItem) 8744 } 8745 8746 logs, sub, err := _MinterRole.contract.WatchLogs(opts, "MinterRemoved", accountRule) 8747 if err != nil { 8748 return nil, err 8749 } 8750 return event.NewSubscription(func(quit <-chan struct{}) error { 8751 defer sub.Unsubscribe() 8752 for { 8753 select { 8754 case log := <-logs: 8755 // New log arrived, parse the event and forward to the user 8756 event := new(MinterRoleMinterRemoved) 8757 if err := _MinterRole.contract.UnpackLog(event, "MinterRemoved", log); err != nil { 8758 return err 8759 } 8760 event.Raw = log 8761 8762 select { 8763 case sink <- event: 8764 case err := <-sub.Err(): 8765 return err 8766 case <-quit: 8767 return nil 8768 } 8769 case err := <-sub.Err(): 8770 return err 8771 case <-quit: 8772 return nil 8773 } 8774 } 8775 }), nil 8776 } 8777 8778 // ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 8779 // 8780 // Solidity: event MinterRemoved(address indexed account) 8781 func (_MinterRole *MinterRoleFilterer) ParseMinterRemoved(log types.Log) (*MinterRoleMinterRemoved, error) { 8782 event := new(MinterRoleMinterRemoved) 8783 if err := _MinterRole.contract.UnpackLog(event, "MinterRemoved", log); err != nil { 8784 return nil, err 8785 } 8786 return event, nil 8787 } 8788 8789 // MinterRoleRenounceTargetABI is the input ABI used to generate the binding from. 8790 const MinterRoleRenounceTargetABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 8791 8792 // MinterRoleRenounceTargetFuncSigs maps the 4-byte function signature to its string representation. 8793 var MinterRoleRenounceTargetFuncSigs = map[string]string{ 8794 "98650275": "renounceMinter()", 8795 } 8796 8797 // MinterRoleRenounceTarget is an auto generated Go binding around an Ethereum contract. 8798 type MinterRoleRenounceTarget struct { 8799 MinterRoleRenounceTargetCaller // Read-only binding to the contract 8800 MinterRoleRenounceTargetTransactor // Write-only binding to the contract 8801 MinterRoleRenounceTargetFilterer // Log filterer for contract events 8802 } 8803 8804 // MinterRoleRenounceTargetCaller is an auto generated read-only Go binding around an Ethereum contract. 8805 type MinterRoleRenounceTargetCaller struct { 8806 contract *bind.BoundContract // Generic contract wrapper for the low level calls 8807 } 8808 8809 // MinterRoleRenounceTargetTransactor is an auto generated write-only Go binding around an Ethereum contract. 8810 type MinterRoleRenounceTargetTransactor struct { 8811 contract *bind.BoundContract // Generic contract wrapper for the low level calls 8812 } 8813 8814 // MinterRoleRenounceTargetFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 8815 type MinterRoleRenounceTargetFilterer struct { 8816 contract *bind.BoundContract // Generic contract wrapper for the low level calls 8817 } 8818 8819 // MinterRoleRenounceTargetSession is an auto generated Go binding around an Ethereum contract, 8820 // with pre-set call and transact options. 8821 type MinterRoleRenounceTargetSession struct { 8822 Contract *MinterRoleRenounceTarget // Generic contract binding to set the session for 8823 CallOpts bind.CallOpts // Call options to use throughout this session 8824 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 8825 } 8826 8827 // MinterRoleRenounceTargetCallerSession is an auto generated read-only Go binding around an Ethereum contract, 8828 // with pre-set call options. 8829 type MinterRoleRenounceTargetCallerSession struct { 8830 Contract *MinterRoleRenounceTargetCaller // Generic contract caller binding to set the session for 8831 CallOpts bind.CallOpts // Call options to use throughout this session 8832 } 8833 8834 // MinterRoleRenounceTargetTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 8835 // with pre-set transact options. 8836 type MinterRoleRenounceTargetTransactorSession struct { 8837 Contract *MinterRoleRenounceTargetTransactor // Generic contract transactor binding to set the session for 8838 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 8839 } 8840 8841 // MinterRoleRenounceTargetRaw is an auto generated low-level Go binding around an Ethereum contract. 8842 type MinterRoleRenounceTargetRaw struct { 8843 Contract *MinterRoleRenounceTarget // Generic contract binding to access the raw methods on 8844 } 8845 8846 // MinterRoleRenounceTargetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 8847 type MinterRoleRenounceTargetCallerRaw struct { 8848 Contract *MinterRoleRenounceTargetCaller // Generic read-only contract binding to access the raw methods on 8849 } 8850 8851 // MinterRoleRenounceTargetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 8852 type MinterRoleRenounceTargetTransactorRaw struct { 8853 Contract *MinterRoleRenounceTargetTransactor // Generic write-only contract binding to access the raw methods on 8854 } 8855 8856 // NewMinterRoleRenounceTarget creates a new instance of MinterRoleRenounceTarget, bound to a specific deployed contract. 8857 func NewMinterRoleRenounceTarget(address common.Address, backend bind.ContractBackend) (*MinterRoleRenounceTarget, error) { 8858 contract, err := bindMinterRoleRenounceTarget(address, backend, backend, backend) 8859 if err != nil { 8860 return nil, err 8861 } 8862 return &MinterRoleRenounceTarget{MinterRoleRenounceTargetCaller: MinterRoleRenounceTargetCaller{contract: contract}, MinterRoleRenounceTargetTransactor: MinterRoleRenounceTargetTransactor{contract: contract}, MinterRoleRenounceTargetFilterer: MinterRoleRenounceTargetFilterer{contract: contract}}, nil 8863 } 8864 8865 // NewMinterRoleRenounceTargetCaller creates a new read-only instance of MinterRoleRenounceTarget, bound to a specific deployed contract. 8866 func NewMinterRoleRenounceTargetCaller(address common.Address, caller bind.ContractCaller) (*MinterRoleRenounceTargetCaller, error) { 8867 contract, err := bindMinterRoleRenounceTarget(address, caller, nil, nil) 8868 if err != nil { 8869 return nil, err 8870 } 8871 return &MinterRoleRenounceTargetCaller{contract: contract}, nil 8872 } 8873 8874 // NewMinterRoleRenounceTargetTransactor creates a new write-only instance of MinterRoleRenounceTarget, bound to a specific deployed contract. 8875 func NewMinterRoleRenounceTargetTransactor(address common.Address, transactor bind.ContractTransactor) (*MinterRoleRenounceTargetTransactor, error) { 8876 contract, err := bindMinterRoleRenounceTarget(address, nil, transactor, nil) 8877 if err != nil { 8878 return nil, err 8879 } 8880 return &MinterRoleRenounceTargetTransactor{contract: contract}, nil 8881 } 8882 8883 // NewMinterRoleRenounceTargetFilterer creates a new log filterer instance of MinterRoleRenounceTarget, bound to a specific deployed contract. 8884 func NewMinterRoleRenounceTargetFilterer(address common.Address, filterer bind.ContractFilterer) (*MinterRoleRenounceTargetFilterer, error) { 8885 contract, err := bindMinterRoleRenounceTarget(address, nil, nil, filterer) 8886 if err != nil { 8887 return nil, err 8888 } 8889 return &MinterRoleRenounceTargetFilterer{contract: contract}, nil 8890 } 8891 8892 // bindMinterRoleRenounceTarget binds a generic wrapper to an already deployed contract. 8893 func bindMinterRoleRenounceTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 8894 parsed, err := abi.JSON(strings.NewReader(MinterRoleRenounceTargetABI)) 8895 if err != nil { 8896 return nil, err 8897 } 8898 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 8899 } 8900 8901 // Call invokes the (constant) contract method with params as input values and 8902 // sets the output to result. The result type might be a single field for simple 8903 // returns, a slice of interfaces for anonymous returns and a struct for named 8904 // returns. 8905 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 8906 return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetCaller.contract.Call(opts, result, method, params...) 8907 } 8908 8909 // Transfer initiates a plain transaction to move funds to the contract, calling 8910 // its default method if one is available. 8911 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 8912 return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetTransactor.contract.Transfer(opts) 8913 } 8914 8915 // Transact invokes the (paid) contract method with params as input values. 8916 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 8917 return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetTransactor.contract.Transact(opts, method, params...) 8918 } 8919 8920 // Call invokes the (constant) contract method with params as input values and 8921 // sets the output to result. The result type might be a single field for simple 8922 // returns, a slice of interfaces for anonymous returns and a struct for named 8923 // returns. 8924 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 8925 return _MinterRoleRenounceTarget.Contract.contract.Call(opts, result, method, params...) 8926 } 8927 8928 // Transfer initiates a plain transaction to move funds to the contract, calling 8929 // its default method if one is available. 8930 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 8931 return _MinterRoleRenounceTarget.Contract.contract.Transfer(opts) 8932 } 8933 8934 // Transact invokes the (paid) contract method with params as input values. 8935 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 8936 return _MinterRoleRenounceTarget.Contract.contract.Transact(opts, method, params...) 8937 } 8938 8939 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 8940 // 8941 // Solidity: function renounceMinter() returns() 8942 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) { 8943 return _MinterRoleRenounceTarget.contract.Transact(opts, "renounceMinter") 8944 } 8945 8946 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 8947 // 8948 // Solidity: function renounceMinter() returns() 8949 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetSession) RenounceMinter() (*types.Transaction, error) { 8950 return _MinterRoleRenounceTarget.Contract.RenounceMinter(&_MinterRoleRenounceTarget.TransactOpts) 8951 } 8952 8953 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 8954 // 8955 // Solidity: function renounceMinter() returns() 8956 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorSession) RenounceMinter() (*types.Transaction, error) { 8957 return _MinterRoleRenounceTarget.Contract.RenounceMinter(&_MinterRoleRenounceTarget.TransactOpts) 8958 } 8959 8960 // OnApproveABI is the input ABI used to generate the binding from. 8961 const OnApproveABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"constant\":true,\"inputs\":[],\"name\":\"INTERFACE_ID_ON_APPROVE\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onApprove\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]" 8962 8963 // OnApproveFuncSigs maps the 4-byte function signature to its string representation. 8964 var OnApproveFuncSigs = map[string]string{ 8965 "6cd28f9a": "INTERFACE_ID_ON_APPROVE()", 8966 "4273ca16": "onApprove(address,address,uint256,bytes)", 8967 "01ffc9a7": "supportsInterface(bytes4)", 8968 } 8969 8970 // OnApprove is an auto generated Go binding around an Ethereum contract. 8971 type OnApprove struct { 8972 OnApproveCaller // Read-only binding to the contract 8973 OnApproveTransactor // Write-only binding to the contract 8974 OnApproveFilterer // Log filterer for contract events 8975 } 8976 8977 // OnApproveCaller is an auto generated read-only Go binding around an Ethereum contract. 8978 type OnApproveCaller struct { 8979 contract *bind.BoundContract // Generic contract wrapper for the low level calls 8980 } 8981 8982 // OnApproveTransactor is an auto generated write-only Go binding around an Ethereum contract. 8983 type OnApproveTransactor struct { 8984 contract *bind.BoundContract // Generic contract wrapper for the low level calls 8985 } 8986 8987 // OnApproveFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 8988 type OnApproveFilterer struct { 8989 contract *bind.BoundContract // Generic contract wrapper for the low level calls 8990 } 8991 8992 // OnApproveSession is an auto generated Go binding around an Ethereum contract, 8993 // with pre-set call and transact options. 8994 type OnApproveSession struct { 8995 Contract *OnApprove // Generic contract binding to set the session for 8996 CallOpts bind.CallOpts // Call options to use throughout this session 8997 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 8998 } 8999 9000 // OnApproveCallerSession is an auto generated read-only Go binding around an Ethereum contract, 9001 // with pre-set call options. 9002 type OnApproveCallerSession struct { 9003 Contract *OnApproveCaller // Generic contract caller binding to set the session for 9004 CallOpts bind.CallOpts // Call options to use throughout this session 9005 } 9006 9007 // OnApproveTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 9008 // with pre-set transact options. 9009 type OnApproveTransactorSession struct { 9010 Contract *OnApproveTransactor // Generic contract transactor binding to set the session for 9011 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 9012 } 9013 9014 // OnApproveRaw is an auto generated low-level Go binding around an Ethereum contract. 9015 type OnApproveRaw struct { 9016 Contract *OnApprove // Generic contract binding to access the raw methods on 9017 } 9018 9019 // OnApproveCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 9020 type OnApproveCallerRaw struct { 9021 Contract *OnApproveCaller // Generic read-only contract binding to access the raw methods on 9022 } 9023 9024 // OnApproveTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 9025 type OnApproveTransactorRaw struct { 9026 Contract *OnApproveTransactor // Generic write-only contract binding to access the raw methods on 9027 } 9028 9029 // NewOnApprove creates a new instance of OnApprove, bound to a specific deployed contract. 9030 func NewOnApprove(address common.Address, backend bind.ContractBackend) (*OnApprove, error) { 9031 contract, err := bindOnApprove(address, backend, backend, backend) 9032 if err != nil { 9033 return nil, err 9034 } 9035 return &OnApprove{OnApproveCaller: OnApproveCaller{contract: contract}, OnApproveTransactor: OnApproveTransactor{contract: contract}, OnApproveFilterer: OnApproveFilterer{contract: contract}}, nil 9036 } 9037 9038 // NewOnApproveCaller creates a new read-only instance of OnApprove, bound to a specific deployed contract. 9039 func NewOnApproveCaller(address common.Address, caller bind.ContractCaller) (*OnApproveCaller, error) { 9040 contract, err := bindOnApprove(address, caller, nil, nil) 9041 if err != nil { 9042 return nil, err 9043 } 9044 return &OnApproveCaller{contract: contract}, nil 9045 } 9046 9047 // NewOnApproveTransactor creates a new write-only instance of OnApprove, bound to a specific deployed contract. 9048 func NewOnApproveTransactor(address common.Address, transactor bind.ContractTransactor) (*OnApproveTransactor, error) { 9049 contract, err := bindOnApprove(address, nil, transactor, nil) 9050 if err != nil { 9051 return nil, err 9052 } 9053 return &OnApproveTransactor{contract: contract}, nil 9054 } 9055 9056 // NewOnApproveFilterer creates a new log filterer instance of OnApprove, bound to a specific deployed contract. 9057 func NewOnApproveFilterer(address common.Address, filterer bind.ContractFilterer) (*OnApproveFilterer, error) { 9058 contract, err := bindOnApprove(address, nil, nil, filterer) 9059 if err != nil { 9060 return nil, err 9061 } 9062 return &OnApproveFilterer{contract: contract}, nil 9063 } 9064 9065 // bindOnApprove binds a generic wrapper to an already deployed contract. 9066 func bindOnApprove(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 9067 parsed, err := abi.JSON(strings.NewReader(OnApproveABI)) 9068 if err != nil { 9069 return nil, err 9070 } 9071 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 9072 } 9073 9074 // Call invokes the (constant) contract method with params as input values and 9075 // sets the output to result. The result type might be a single field for simple 9076 // returns, a slice of interfaces for anonymous returns and a struct for named 9077 // returns. 9078 func (_OnApprove *OnApproveRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 9079 return _OnApprove.Contract.OnApproveCaller.contract.Call(opts, result, method, params...) 9080 } 9081 9082 // Transfer initiates a plain transaction to move funds to the contract, calling 9083 // its default method if one is available. 9084 func (_OnApprove *OnApproveRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 9085 return _OnApprove.Contract.OnApproveTransactor.contract.Transfer(opts) 9086 } 9087 9088 // Transact invokes the (paid) contract method with params as input values. 9089 func (_OnApprove *OnApproveRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 9090 return _OnApprove.Contract.OnApproveTransactor.contract.Transact(opts, method, params...) 9091 } 9092 9093 // Call invokes the (constant) contract method with params as input values and 9094 // sets the output to result. The result type might be a single field for simple 9095 // returns, a slice of interfaces for anonymous returns and a struct for named 9096 // returns. 9097 func (_OnApprove *OnApproveCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 9098 return _OnApprove.Contract.contract.Call(opts, result, method, params...) 9099 } 9100 9101 // Transfer initiates a plain transaction to move funds to the contract, calling 9102 // its default method if one is available. 9103 func (_OnApprove *OnApproveTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 9104 return _OnApprove.Contract.contract.Transfer(opts) 9105 } 9106 9107 // Transact invokes the (paid) contract method with params as input values. 9108 func (_OnApprove *OnApproveTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 9109 return _OnApprove.Contract.contract.Transact(opts, method, params...) 9110 } 9111 9112 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 9113 // 9114 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 9115 func (_OnApprove *OnApproveCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) { 9116 var ( 9117 ret0 = new([4]byte) 9118 ) 9119 out := ret0 9120 err := _OnApprove.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE") 9121 return *ret0, err 9122 } 9123 9124 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 9125 // 9126 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 9127 func (_OnApprove *OnApproveSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 9128 return _OnApprove.Contract.INTERFACEIDONAPPROVE(&_OnApprove.CallOpts) 9129 } 9130 9131 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 9132 // 9133 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 9134 func (_OnApprove *OnApproveCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 9135 return _OnApprove.Contract.INTERFACEIDONAPPROVE(&_OnApprove.CallOpts) 9136 } 9137 9138 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 9139 // 9140 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 9141 func (_OnApprove *OnApproveCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { 9142 var ( 9143 ret0 = new(bool) 9144 ) 9145 out := ret0 9146 err := _OnApprove.contract.Call(opts, out, "supportsInterface", interfaceId) 9147 return *ret0, err 9148 } 9149 9150 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 9151 // 9152 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 9153 func (_OnApprove *OnApproveSession) SupportsInterface(interfaceId [4]byte) (bool, error) { 9154 return _OnApprove.Contract.SupportsInterface(&_OnApprove.CallOpts, interfaceId) 9155 } 9156 9157 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 9158 // 9159 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 9160 func (_OnApprove *OnApproveCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { 9161 return _OnApprove.Contract.SupportsInterface(&_OnApprove.CallOpts, interfaceId) 9162 } 9163 9164 // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16. 9165 // 9166 // Solidity: function onApprove(address owner, address spender, uint256 amount, bytes data) returns(bool) 9167 func (_OnApprove *OnApproveTransactor) OnApprove(opts *bind.TransactOpts, owner common.Address, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 9168 return _OnApprove.contract.Transact(opts, "onApprove", owner, spender, amount, data) 9169 } 9170 9171 // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16. 9172 // 9173 // Solidity: function onApprove(address owner, address spender, uint256 amount, bytes data) returns(bool) 9174 func (_OnApprove *OnApproveSession) OnApprove(owner common.Address, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 9175 return _OnApprove.Contract.OnApprove(&_OnApprove.TransactOpts, owner, spender, amount, data) 9176 } 9177 9178 // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16. 9179 // 9180 // Solidity: function onApprove(address owner, address spender, uint256 amount, bytes data) returns(bool) 9181 func (_OnApprove *OnApproveTransactorSession) OnApprove(owner common.Address, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 9182 return _OnApprove.Contract.OnApprove(&_OnApprove.TransactOpts, owner, spender, amount, data) 9183 } 9184 9185 // OnApproveConstantABI is the input ABI used to generate the binding from. 9186 const OnApproveConstantABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"INTERFACE_ID_ON_APPROVE\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]" 9187 9188 // OnApproveConstantFuncSigs maps the 4-byte function signature to its string representation. 9189 var OnApproveConstantFuncSigs = map[string]string{ 9190 "6cd28f9a": "INTERFACE_ID_ON_APPROVE()", 9191 } 9192 9193 // OnApproveConstantBin is the compiled bytecode used for deploying new contracts. 9194 var OnApproveConstantBin = "0x6080604052348015600f57600080fd5b5060c78061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c80636cd28f9a14602d575b600080fd5b60336050565b604080516001600160e01b03199092168252519081900360200190f35b604051806028606b8239602801905060405180910390208156fe6f6e417070726f766528616464726573732c616464726573732c75696e743235362c627974657329a265627a7a723158206d94182e39f46cad6425154650e56ecd40259e07a64364bd131e67fe91c85c7664736f6c634300050c0032" 9195 9196 // DeployOnApproveConstant deploys a new Ethereum contract, binding an instance of OnApproveConstant to it. 9197 func DeployOnApproveConstant(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *OnApproveConstant, error) { 9198 parsed, err := abi.JSON(strings.NewReader(OnApproveConstantABI)) 9199 if err != nil { 9200 return common.Address{}, nil, nil, err 9201 } 9202 9203 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(OnApproveConstantBin), backend) 9204 if err != nil { 9205 return common.Address{}, nil, nil, err 9206 } 9207 return address, tx, &OnApproveConstant{OnApproveConstantCaller: OnApproveConstantCaller{contract: contract}, OnApproveConstantTransactor: OnApproveConstantTransactor{contract: contract}, OnApproveConstantFilterer: OnApproveConstantFilterer{contract: contract}}, nil 9208 } 9209 9210 // OnApproveConstant is an auto generated Go binding around an Ethereum contract. 9211 type OnApproveConstant struct { 9212 OnApproveConstantCaller // Read-only binding to the contract 9213 OnApproveConstantTransactor // Write-only binding to the contract 9214 OnApproveConstantFilterer // Log filterer for contract events 9215 } 9216 9217 // OnApproveConstantCaller is an auto generated read-only Go binding around an Ethereum contract. 9218 type OnApproveConstantCaller struct { 9219 contract *bind.BoundContract // Generic contract wrapper for the low level calls 9220 } 9221 9222 // OnApproveConstantTransactor is an auto generated write-only Go binding around an Ethereum contract. 9223 type OnApproveConstantTransactor struct { 9224 contract *bind.BoundContract // Generic contract wrapper for the low level calls 9225 } 9226 9227 // OnApproveConstantFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 9228 type OnApproveConstantFilterer struct { 9229 contract *bind.BoundContract // Generic contract wrapper for the low level calls 9230 } 9231 9232 // OnApproveConstantSession is an auto generated Go binding around an Ethereum contract, 9233 // with pre-set call and transact options. 9234 type OnApproveConstantSession struct { 9235 Contract *OnApproveConstant // Generic contract binding to set the session for 9236 CallOpts bind.CallOpts // Call options to use throughout this session 9237 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 9238 } 9239 9240 // OnApproveConstantCallerSession is an auto generated read-only Go binding around an Ethereum contract, 9241 // with pre-set call options. 9242 type OnApproveConstantCallerSession struct { 9243 Contract *OnApproveConstantCaller // Generic contract caller binding to set the session for 9244 CallOpts bind.CallOpts // Call options to use throughout this session 9245 } 9246 9247 // OnApproveConstantTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 9248 // with pre-set transact options. 9249 type OnApproveConstantTransactorSession struct { 9250 Contract *OnApproveConstantTransactor // Generic contract transactor binding to set the session for 9251 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 9252 } 9253 9254 // OnApproveConstantRaw is an auto generated low-level Go binding around an Ethereum contract. 9255 type OnApproveConstantRaw struct { 9256 Contract *OnApproveConstant // Generic contract binding to access the raw methods on 9257 } 9258 9259 // OnApproveConstantCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 9260 type OnApproveConstantCallerRaw struct { 9261 Contract *OnApproveConstantCaller // Generic read-only contract binding to access the raw methods on 9262 } 9263 9264 // OnApproveConstantTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 9265 type OnApproveConstantTransactorRaw struct { 9266 Contract *OnApproveConstantTransactor // Generic write-only contract binding to access the raw methods on 9267 } 9268 9269 // NewOnApproveConstant creates a new instance of OnApproveConstant, bound to a specific deployed contract. 9270 func NewOnApproveConstant(address common.Address, backend bind.ContractBackend) (*OnApproveConstant, error) { 9271 contract, err := bindOnApproveConstant(address, backend, backend, backend) 9272 if err != nil { 9273 return nil, err 9274 } 9275 return &OnApproveConstant{OnApproveConstantCaller: OnApproveConstantCaller{contract: contract}, OnApproveConstantTransactor: OnApproveConstantTransactor{contract: contract}, OnApproveConstantFilterer: OnApproveConstantFilterer{contract: contract}}, nil 9276 } 9277 9278 // NewOnApproveConstantCaller creates a new read-only instance of OnApproveConstant, bound to a specific deployed contract. 9279 func NewOnApproveConstantCaller(address common.Address, caller bind.ContractCaller) (*OnApproveConstantCaller, error) { 9280 contract, err := bindOnApproveConstant(address, caller, nil, nil) 9281 if err != nil { 9282 return nil, err 9283 } 9284 return &OnApproveConstantCaller{contract: contract}, nil 9285 } 9286 9287 // NewOnApproveConstantTransactor creates a new write-only instance of OnApproveConstant, bound to a specific deployed contract. 9288 func NewOnApproveConstantTransactor(address common.Address, transactor bind.ContractTransactor) (*OnApproveConstantTransactor, error) { 9289 contract, err := bindOnApproveConstant(address, nil, transactor, nil) 9290 if err != nil { 9291 return nil, err 9292 } 9293 return &OnApproveConstantTransactor{contract: contract}, nil 9294 } 9295 9296 // NewOnApproveConstantFilterer creates a new log filterer instance of OnApproveConstant, bound to a specific deployed contract. 9297 func NewOnApproveConstantFilterer(address common.Address, filterer bind.ContractFilterer) (*OnApproveConstantFilterer, error) { 9298 contract, err := bindOnApproveConstant(address, nil, nil, filterer) 9299 if err != nil { 9300 return nil, err 9301 } 9302 return &OnApproveConstantFilterer{contract: contract}, nil 9303 } 9304 9305 // bindOnApproveConstant binds a generic wrapper to an already deployed contract. 9306 func bindOnApproveConstant(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 9307 parsed, err := abi.JSON(strings.NewReader(OnApproveConstantABI)) 9308 if err != nil { 9309 return nil, err 9310 } 9311 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 9312 } 9313 9314 // Call invokes the (constant) contract method with params as input values and 9315 // sets the output to result. The result type might be a single field for simple 9316 // returns, a slice of interfaces for anonymous returns and a struct for named 9317 // returns. 9318 func (_OnApproveConstant *OnApproveConstantRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 9319 return _OnApproveConstant.Contract.OnApproveConstantCaller.contract.Call(opts, result, method, params...) 9320 } 9321 9322 // Transfer initiates a plain transaction to move funds to the contract, calling 9323 // its default method if one is available. 9324 func (_OnApproveConstant *OnApproveConstantRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 9325 return _OnApproveConstant.Contract.OnApproveConstantTransactor.contract.Transfer(opts) 9326 } 9327 9328 // Transact invokes the (paid) contract method with params as input values. 9329 func (_OnApproveConstant *OnApproveConstantRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 9330 return _OnApproveConstant.Contract.OnApproveConstantTransactor.contract.Transact(opts, method, params...) 9331 } 9332 9333 // Call invokes the (constant) contract method with params as input values and 9334 // sets the output to result. The result type might be a single field for simple 9335 // returns, a slice of interfaces for anonymous returns and a struct for named 9336 // returns. 9337 func (_OnApproveConstant *OnApproveConstantCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 9338 return _OnApproveConstant.Contract.contract.Call(opts, result, method, params...) 9339 } 9340 9341 // Transfer initiates a plain transaction to move funds to the contract, calling 9342 // its default method if one is available. 9343 func (_OnApproveConstant *OnApproveConstantTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 9344 return _OnApproveConstant.Contract.contract.Transfer(opts) 9345 } 9346 9347 // Transact invokes the (paid) contract method with params as input values. 9348 func (_OnApproveConstant *OnApproveConstantTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 9349 return _OnApproveConstant.Contract.contract.Transact(opts, method, params...) 9350 } 9351 9352 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 9353 // 9354 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 9355 func (_OnApproveConstant *OnApproveConstantCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) { 9356 var ( 9357 ret0 = new([4]byte) 9358 ) 9359 out := ret0 9360 err := _OnApproveConstant.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE") 9361 return *ret0, err 9362 } 9363 9364 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 9365 // 9366 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 9367 func (_OnApproveConstant *OnApproveConstantSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 9368 return _OnApproveConstant.Contract.INTERFACEIDONAPPROVE(&_OnApproveConstant.CallOpts) 9369 } 9370 9371 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 9372 // 9373 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 9374 func (_OnApproveConstant *OnApproveConstantCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 9375 return _OnApproveConstant.Contract.INTERFACEIDONAPPROVE(&_OnApproveConstant.CallOpts) 9376 } 9377 9378 // OwnableABI is the input ABI used to generate the binding from. 9379 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\"}]" 9380 9381 // OwnableFuncSigs maps the 4-byte function signature to its string representation. 9382 var OwnableFuncSigs = map[string]string{ 9383 "8f32d59b": "isOwner()", 9384 "8da5cb5b": "owner()", 9385 "715018a6": "renounceOwnership()", 9386 "f2fde38b": "transferOwnership(address)", 9387 } 9388 9389 // Ownable is an auto generated Go binding around an Ethereum contract. 9390 type Ownable struct { 9391 OwnableCaller // Read-only binding to the contract 9392 OwnableTransactor // Write-only binding to the contract 9393 OwnableFilterer // Log filterer for contract events 9394 } 9395 9396 // OwnableCaller is an auto generated read-only Go binding around an Ethereum contract. 9397 type OwnableCaller struct { 9398 contract *bind.BoundContract // Generic contract wrapper for the low level calls 9399 } 9400 9401 // OwnableTransactor is an auto generated write-only Go binding around an Ethereum contract. 9402 type OwnableTransactor struct { 9403 contract *bind.BoundContract // Generic contract wrapper for the low level calls 9404 } 9405 9406 // OwnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 9407 type OwnableFilterer struct { 9408 contract *bind.BoundContract // Generic contract wrapper for the low level calls 9409 } 9410 9411 // OwnableSession is an auto generated Go binding around an Ethereum contract, 9412 // with pre-set call and transact options. 9413 type OwnableSession struct { 9414 Contract *Ownable // Generic contract binding to set the session for 9415 CallOpts bind.CallOpts // Call options to use throughout this session 9416 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 9417 } 9418 9419 // OwnableCallerSession is an auto generated read-only Go binding around an Ethereum contract, 9420 // with pre-set call options. 9421 type OwnableCallerSession struct { 9422 Contract *OwnableCaller // Generic contract caller binding to set the session for 9423 CallOpts bind.CallOpts // Call options to use throughout this session 9424 } 9425 9426 // OwnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 9427 // with pre-set transact options. 9428 type OwnableTransactorSession struct { 9429 Contract *OwnableTransactor // Generic contract transactor binding to set the session for 9430 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 9431 } 9432 9433 // OwnableRaw is an auto generated low-level Go binding around an Ethereum contract. 9434 type OwnableRaw struct { 9435 Contract *Ownable // Generic contract binding to access the raw methods on 9436 } 9437 9438 // OwnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 9439 type OwnableCallerRaw struct { 9440 Contract *OwnableCaller // Generic read-only contract binding to access the raw methods on 9441 } 9442 9443 // OwnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 9444 type OwnableTransactorRaw struct { 9445 Contract *OwnableTransactor // Generic write-only contract binding to access the raw methods on 9446 } 9447 9448 // NewOwnable creates a new instance of Ownable, bound to a specific deployed contract. 9449 func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error) { 9450 contract, err := bindOwnable(address, backend, backend, backend) 9451 if err != nil { 9452 return nil, err 9453 } 9454 return &Ownable{OwnableCaller: OwnableCaller{contract: contract}, OwnableTransactor: OwnableTransactor{contract: contract}, OwnableFilterer: OwnableFilterer{contract: contract}}, nil 9455 } 9456 9457 // NewOwnableCaller creates a new read-only instance of Ownable, bound to a specific deployed contract. 9458 func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error) { 9459 contract, err := bindOwnable(address, caller, nil, nil) 9460 if err != nil { 9461 return nil, err 9462 } 9463 return &OwnableCaller{contract: contract}, nil 9464 } 9465 9466 // NewOwnableTransactor creates a new write-only instance of Ownable, bound to a specific deployed contract. 9467 func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error) { 9468 contract, err := bindOwnable(address, nil, transactor, nil) 9469 if err != nil { 9470 return nil, err 9471 } 9472 return &OwnableTransactor{contract: contract}, nil 9473 } 9474 9475 // NewOwnableFilterer creates a new log filterer instance of Ownable, bound to a specific deployed contract. 9476 func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error) { 9477 contract, err := bindOwnable(address, nil, nil, filterer) 9478 if err != nil { 9479 return nil, err 9480 } 9481 return &OwnableFilterer{contract: contract}, nil 9482 } 9483 9484 // bindOwnable binds a generic wrapper to an already deployed contract. 9485 func bindOwnable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 9486 parsed, err := abi.JSON(strings.NewReader(OwnableABI)) 9487 if err != nil { 9488 return nil, err 9489 } 9490 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 9491 } 9492 9493 // Call invokes the (constant) contract method with params as input values and 9494 // sets the output to result. The result type might be a single field for simple 9495 // returns, a slice of interfaces for anonymous returns and a struct for named 9496 // returns. 9497 func (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 9498 return _Ownable.Contract.OwnableCaller.contract.Call(opts, result, method, params...) 9499 } 9500 9501 // Transfer initiates a plain transaction to move funds to the contract, calling 9502 // its default method if one is available. 9503 func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 9504 return _Ownable.Contract.OwnableTransactor.contract.Transfer(opts) 9505 } 9506 9507 // Transact invokes the (paid) contract method with params as input values. 9508 func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 9509 return _Ownable.Contract.OwnableTransactor.contract.Transact(opts, method, params...) 9510 } 9511 9512 // Call invokes the (constant) contract method with params as input values and 9513 // sets the output to result. The result type might be a single field for simple 9514 // returns, a slice of interfaces for anonymous returns and a struct for named 9515 // returns. 9516 func (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 9517 return _Ownable.Contract.contract.Call(opts, result, method, params...) 9518 } 9519 9520 // Transfer initiates a plain transaction to move funds to the contract, calling 9521 // its default method if one is available. 9522 func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 9523 return _Ownable.Contract.contract.Transfer(opts) 9524 } 9525 9526 // Transact invokes the (paid) contract method with params as input values. 9527 func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 9528 return _Ownable.Contract.contract.Transact(opts, method, params...) 9529 } 9530 9531 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 9532 // 9533 // Solidity: function isOwner() constant returns(bool) 9534 func (_Ownable *OwnableCaller) IsOwner(opts *bind.CallOpts) (bool, error) { 9535 var ( 9536 ret0 = new(bool) 9537 ) 9538 out := ret0 9539 err := _Ownable.contract.Call(opts, out, "isOwner") 9540 return *ret0, err 9541 } 9542 9543 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 9544 // 9545 // Solidity: function isOwner() constant returns(bool) 9546 func (_Ownable *OwnableSession) IsOwner() (bool, error) { 9547 return _Ownable.Contract.IsOwner(&_Ownable.CallOpts) 9548 } 9549 9550 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 9551 // 9552 // Solidity: function isOwner() constant returns(bool) 9553 func (_Ownable *OwnableCallerSession) IsOwner() (bool, error) { 9554 return _Ownable.Contract.IsOwner(&_Ownable.CallOpts) 9555 } 9556 9557 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 9558 // 9559 // Solidity: function owner() constant returns(address) 9560 func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 9561 var ( 9562 ret0 = new(common.Address) 9563 ) 9564 out := ret0 9565 err := _Ownable.contract.Call(opts, out, "owner") 9566 return *ret0, err 9567 } 9568 9569 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 9570 // 9571 // Solidity: function owner() constant returns(address) 9572 func (_Ownable *OwnableSession) Owner() (common.Address, error) { 9573 return _Ownable.Contract.Owner(&_Ownable.CallOpts) 9574 } 9575 9576 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 9577 // 9578 // Solidity: function owner() constant returns(address) 9579 func (_Ownable *OwnableCallerSession) Owner() (common.Address, error) { 9580 return _Ownable.Contract.Owner(&_Ownable.CallOpts) 9581 } 9582 9583 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 9584 // 9585 // Solidity: function renounceOwnership() returns() 9586 func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { 9587 return _Ownable.contract.Transact(opts, "renounceOwnership") 9588 } 9589 9590 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 9591 // 9592 // Solidity: function renounceOwnership() returns() 9593 func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error) { 9594 return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts) 9595 } 9596 9597 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 9598 // 9599 // Solidity: function renounceOwnership() returns() 9600 func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error) { 9601 return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts) 9602 } 9603 9604 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 9605 // 9606 // Solidity: function transferOwnership(address newOwner) returns() 9607 func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 9608 return _Ownable.contract.Transact(opts, "transferOwnership", newOwner) 9609 } 9610 9611 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 9612 // 9613 // Solidity: function transferOwnership(address newOwner) returns() 9614 func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 9615 return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner) 9616 } 9617 9618 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 9619 // 9620 // Solidity: function transferOwnership(address newOwner) returns() 9621 func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 9622 return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner) 9623 } 9624 9625 // 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. 9626 type OwnableOwnershipTransferredIterator struct { 9627 Event *OwnableOwnershipTransferred // Event containing the contract specifics and raw log 9628 9629 contract *bind.BoundContract // Generic contract to use for unpacking event data 9630 event string // Event name to use for unpacking event data 9631 9632 logs chan types.Log // Log channel receiving the found contract events 9633 sub ethereum.Subscription // Subscription for errors, completion and termination 9634 done bool // Whether the subscription completed delivering logs 9635 fail error // Occurred error to stop iteration 9636 } 9637 9638 // Next advances the iterator to the subsequent event, returning whether there 9639 // are any more events found. In case of a retrieval or parsing error, false is 9640 // returned and Error() can be queried for the exact failure. 9641 func (it *OwnableOwnershipTransferredIterator) Next() bool { 9642 // If the iterator failed, stop iterating 9643 if it.fail != nil { 9644 return false 9645 } 9646 // If the iterator completed, deliver directly whatever's available 9647 if it.done { 9648 select { 9649 case log := <-it.logs: 9650 it.Event = new(OwnableOwnershipTransferred) 9651 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 9652 it.fail = err 9653 return false 9654 } 9655 it.Event.Raw = log 9656 return true 9657 9658 default: 9659 return false 9660 } 9661 } 9662 // Iterator still in progress, wait for either a data or an error event 9663 select { 9664 case log := <-it.logs: 9665 it.Event = new(OwnableOwnershipTransferred) 9666 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 9667 it.fail = err 9668 return false 9669 } 9670 it.Event.Raw = log 9671 return true 9672 9673 case err := <-it.sub.Err(): 9674 it.done = true 9675 it.fail = err 9676 return it.Next() 9677 } 9678 } 9679 9680 // Error returns any retrieval or parsing error occurred during filtering. 9681 func (it *OwnableOwnershipTransferredIterator) Error() error { 9682 return it.fail 9683 } 9684 9685 // Close terminates the iteration process, releasing any pending underlying 9686 // resources. 9687 func (it *OwnableOwnershipTransferredIterator) Close() error { 9688 it.sub.Unsubscribe() 9689 return nil 9690 } 9691 9692 // OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract. 9693 type OwnableOwnershipTransferred struct { 9694 PreviousOwner common.Address 9695 NewOwner common.Address 9696 Raw types.Log // Blockchain specific contextual infos 9697 } 9698 9699 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 9700 // 9701 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 9702 func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OwnableOwnershipTransferredIterator, error) { 9703 9704 var previousOwnerRule []interface{} 9705 for _, previousOwnerItem := range previousOwner { 9706 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 9707 } 9708 var newOwnerRule []interface{} 9709 for _, newOwnerItem := range newOwner { 9710 newOwnerRule = append(newOwnerRule, newOwnerItem) 9711 } 9712 9713 logs, sub, err := _Ownable.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 9714 if err != nil { 9715 return nil, err 9716 } 9717 return &OwnableOwnershipTransferredIterator{contract: _Ownable.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 9718 } 9719 9720 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 9721 // 9722 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 9723 func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 9724 9725 var previousOwnerRule []interface{} 9726 for _, previousOwnerItem := range previousOwner { 9727 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 9728 } 9729 var newOwnerRule []interface{} 9730 for _, newOwnerItem := range newOwner { 9731 newOwnerRule = append(newOwnerRule, newOwnerItem) 9732 } 9733 9734 logs, sub, err := _Ownable.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 9735 if err != nil { 9736 return nil, err 9737 } 9738 return event.NewSubscription(func(quit <-chan struct{}) error { 9739 defer sub.Unsubscribe() 9740 for { 9741 select { 9742 case log := <-logs: 9743 // New log arrived, parse the event and forward to the user 9744 event := new(OwnableOwnershipTransferred) 9745 if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 9746 return err 9747 } 9748 event.Raw = log 9749 9750 select { 9751 case sink <- event: 9752 case err := <-sub.Err(): 9753 return err 9754 case <-quit: 9755 return nil 9756 } 9757 case err := <-sub.Err(): 9758 return err 9759 case <-quit: 9760 return nil 9761 } 9762 } 9763 }), nil 9764 } 9765 9766 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 9767 // 9768 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 9769 func (_Ownable *OwnableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableOwnershipTransferred, error) { 9770 event := new(OwnableOwnershipTransferred) 9771 if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 9772 return nil, err 9773 } 9774 return event, nil 9775 } 9776 9777 // OwnableTargetABI is the input ABI used to generate the binding from. 9778 const OwnableTargetABI = "[{\"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\"}]" 9779 9780 // OwnableTargetFuncSigs maps the 4-byte function signature to its string representation. 9781 var OwnableTargetFuncSigs = map[string]string{ 9782 "715018a6": "renounceOwnership()", 9783 "f2fde38b": "transferOwnership(address)", 9784 } 9785 9786 // OwnableTarget is an auto generated Go binding around an Ethereum contract. 9787 type OwnableTarget struct { 9788 OwnableTargetCaller // Read-only binding to the contract 9789 OwnableTargetTransactor // Write-only binding to the contract 9790 OwnableTargetFilterer // Log filterer for contract events 9791 } 9792 9793 // OwnableTargetCaller is an auto generated read-only Go binding around an Ethereum contract. 9794 type OwnableTargetCaller struct { 9795 contract *bind.BoundContract // Generic contract wrapper for the low level calls 9796 } 9797 9798 // OwnableTargetTransactor is an auto generated write-only Go binding around an Ethereum contract. 9799 type OwnableTargetTransactor struct { 9800 contract *bind.BoundContract // Generic contract wrapper for the low level calls 9801 } 9802 9803 // OwnableTargetFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 9804 type OwnableTargetFilterer struct { 9805 contract *bind.BoundContract // Generic contract wrapper for the low level calls 9806 } 9807 9808 // OwnableTargetSession is an auto generated Go binding around an Ethereum contract, 9809 // with pre-set call and transact options. 9810 type OwnableTargetSession struct { 9811 Contract *OwnableTarget // Generic contract binding to set the session for 9812 CallOpts bind.CallOpts // Call options to use throughout this session 9813 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 9814 } 9815 9816 // OwnableTargetCallerSession is an auto generated read-only Go binding around an Ethereum contract, 9817 // with pre-set call options. 9818 type OwnableTargetCallerSession struct { 9819 Contract *OwnableTargetCaller // Generic contract caller binding to set the session for 9820 CallOpts bind.CallOpts // Call options to use throughout this session 9821 } 9822 9823 // OwnableTargetTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 9824 // with pre-set transact options. 9825 type OwnableTargetTransactorSession struct { 9826 Contract *OwnableTargetTransactor // Generic contract transactor binding to set the session for 9827 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 9828 } 9829 9830 // OwnableTargetRaw is an auto generated low-level Go binding around an Ethereum contract. 9831 type OwnableTargetRaw struct { 9832 Contract *OwnableTarget // Generic contract binding to access the raw methods on 9833 } 9834 9835 // OwnableTargetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 9836 type OwnableTargetCallerRaw struct { 9837 Contract *OwnableTargetCaller // Generic read-only contract binding to access the raw methods on 9838 } 9839 9840 // OwnableTargetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 9841 type OwnableTargetTransactorRaw struct { 9842 Contract *OwnableTargetTransactor // Generic write-only contract binding to access the raw methods on 9843 } 9844 9845 // NewOwnableTarget creates a new instance of OwnableTarget, bound to a specific deployed contract. 9846 func NewOwnableTarget(address common.Address, backend bind.ContractBackend) (*OwnableTarget, error) { 9847 contract, err := bindOwnableTarget(address, backend, backend, backend) 9848 if err != nil { 9849 return nil, err 9850 } 9851 return &OwnableTarget{OwnableTargetCaller: OwnableTargetCaller{contract: contract}, OwnableTargetTransactor: OwnableTargetTransactor{contract: contract}, OwnableTargetFilterer: OwnableTargetFilterer{contract: contract}}, nil 9852 } 9853 9854 // NewOwnableTargetCaller creates a new read-only instance of OwnableTarget, bound to a specific deployed contract. 9855 func NewOwnableTargetCaller(address common.Address, caller bind.ContractCaller) (*OwnableTargetCaller, error) { 9856 contract, err := bindOwnableTarget(address, caller, nil, nil) 9857 if err != nil { 9858 return nil, err 9859 } 9860 return &OwnableTargetCaller{contract: contract}, nil 9861 } 9862 9863 // NewOwnableTargetTransactor creates a new write-only instance of OwnableTarget, bound to a specific deployed contract. 9864 func NewOwnableTargetTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTargetTransactor, error) { 9865 contract, err := bindOwnableTarget(address, nil, transactor, nil) 9866 if err != nil { 9867 return nil, err 9868 } 9869 return &OwnableTargetTransactor{contract: contract}, nil 9870 } 9871 9872 // NewOwnableTargetFilterer creates a new log filterer instance of OwnableTarget, bound to a specific deployed contract. 9873 func NewOwnableTargetFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableTargetFilterer, error) { 9874 contract, err := bindOwnableTarget(address, nil, nil, filterer) 9875 if err != nil { 9876 return nil, err 9877 } 9878 return &OwnableTargetFilterer{contract: contract}, nil 9879 } 9880 9881 // bindOwnableTarget binds a generic wrapper to an already deployed contract. 9882 func bindOwnableTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 9883 parsed, err := abi.JSON(strings.NewReader(OwnableTargetABI)) 9884 if err != nil { 9885 return nil, err 9886 } 9887 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 9888 } 9889 9890 // Call invokes the (constant) contract method with params as input values and 9891 // sets the output to result. The result type might be a single field for simple 9892 // returns, a slice of interfaces for anonymous returns and a struct for named 9893 // returns. 9894 func (_OwnableTarget *OwnableTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 9895 return _OwnableTarget.Contract.OwnableTargetCaller.contract.Call(opts, result, method, params...) 9896 } 9897 9898 // Transfer initiates a plain transaction to move funds to the contract, calling 9899 // its default method if one is available. 9900 func (_OwnableTarget *OwnableTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 9901 return _OwnableTarget.Contract.OwnableTargetTransactor.contract.Transfer(opts) 9902 } 9903 9904 // Transact invokes the (paid) contract method with params as input values. 9905 func (_OwnableTarget *OwnableTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 9906 return _OwnableTarget.Contract.OwnableTargetTransactor.contract.Transact(opts, method, params...) 9907 } 9908 9909 // Call invokes the (constant) contract method with params as input values and 9910 // sets the output to result. The result type might be a single field for simple 9911 // returns, a slice of interfaces for anonymous returns and a struct for named 9912 // returns. 9913 func (_OwnableTarget *OwnableTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 9914 return _OwnableTarget.Contract.contract.Call(opts, result, method, params...) 9915 } 9916 9917 // Transfer initiates a plain transaction to move funds to the contract, calling 9918 // its default method if one is available. 9919 func (_OwnableTarget *OwnableTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 9920 return _OwnableTarget.Contract.contract.Transfer(opts) 9921 } 9922 9923 // Transact invokes the (paid) contract method with params as input values. 9924 func (_OwnableTarget *OwnableTargetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 9925 return _OwnableTarget.Contract.contract.Transact(opts, method, params...) 9926 } 9927 9928 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 9929 // 9930 // Solidity: function renounceOwnership() returns() 9931 func (_OwnableTarget *OwnableTargetTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { 9932 return _OwnableTarget.contract.Transact(opts, "renounceOwnership") 9933 } 9934 9935 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 9936 // 9937 // Solidity: function renounceOwnership() returns() 9938 func (_OwnableTarget *OwnableTargetSession) RenounceOwnership() (*types.Transaction, error) { 9939 return _OwnableTarget.Contract.RenounceOwnership(&_OwnableTarget.TransactOpts) 9940 } 9941 9942 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 9943 // 9944 // Solidity: function renounceOwnership() returns() 9945 func (_OwnableTarget *OwnableTargetTransactorSession) RenounceOwnership() (*types.Transaction, error) { 9946 return _OwnableTarget.Contract.RenounceOwnership(&_OwnableTarget.TransactOpts) 9947 } 9948 9949 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 9950 // 9951 // Solidity: function transferOwnership(address newOwner) returns() 9952 func (_OwnableTarget *OwnableTargetTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 9953 return _OwnableTarget.contract.Transact(opts, "transferOwnership", newOwner) 9954 } 9955 9956 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 9957 // 9958 // Solidity: function transferOwnership(address newOwner) returns() 9959 func (_OwnableTarget *OwnableTargetSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 9960 return _OwnableTarget.Contract.TransferOwnership(&_OwnableTarget.TransactOpts, newOwner) 9961 } 9962 9963 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 9964 // 9965 // Solidity: function transferOwnership(address newOwner) returns() 9966 func (_OwnableTarget *OwnableTargetTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 9967 return _OwnableTarget.Contract.TransferOwnership(&_OwnableTarget.TransactOpts, newOwner) 9968 } 9969 9970 // PauserRoleRenounceTargetABI is the input ABI used to generate the binding from. 9971 const PauserRoleRenounceTargetABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 9972 9973 // PauserRoleRenounceTargetFuncSigs maps the 4-byte function signature to its string representation. 9974 var PauserRoleRenounceTargetFuncSigs = map[string]string{ 9975 "6ef8d66d": "renouncePauser()", 9976 } 9977 9978 // PauserRoleRenounceTarget is an auto generated Go binding around an Ethereum contract. 9979 type PauserRoleRenounceTarget struct { 9980 PauserRoleRenounceTargetCaller // Read-only binding to the contract 9981 PauserRoleRenounceTargetTransactor // Write-only binding to the contract 9982 PauserRoleRenounceTargetFilterer // Log filterer for contract events 9983 } 9984 9985 // PauserRoleRenounceTargetCaller is an auto generated read-only Go binding around an Ethereum contract. 9986 type PauserRoleRenounceTargetCaller struct { 9987 contract *bind.BoundContract // Generic contract wrapper for the low level calls 9988 } 9989 9990 // PauserRoleRenounceTargetTransactor is an auto generated write-only Go binding around an Ethereum contract. 9991 type PauserRoleRenounceTargetTransactor struct { 9992 contract *bind.BoundContract // Generic contract wrapper for the low level calls 9993 } 9994 9995 // PauserRoleRenounceTargetFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 9996 type PauserRoleRenounceTargetFilterer struct { 9997 contract *bind.BoundContract // Generic contract wrapper for the low level calls 9998 } 9999 10000 // PauserRoleRenounceTargetSession is an auto generated Go binding around an Ethereum contract, 10001 // with pre-set call and transact options. 10002 type PauserRoleRenounceTargetSession struct { 10003 Contract *PauserRoleRenounceTarget // Generic contract binding to set the session for 10004 CallOpts bind.CallOpts // Call options to use throughout this session 10005 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 10006 } 10007 10008 // PauserRoleRenounceTargetCallerSession is an auto generated read-only Go binding around an Ethereum contract, 10009 // with pre-set call options. 10010 type PauserRoleRenounceTargetCallerSession struct { 10011 Contract *PauserRoleRenounceTargetCaller // Generic contract caller binding to set the session for 10012 CallOpts bind.CallOpts // Call options to use throughout this session 10013 } 10014 10015 // PauserRoleRenounceTargetTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 10016 // with pre-set transact options. 10017 type PauserRoleRenounceTargetTransactorSession struct { 10018 Contract *PauserRoleRenounceTargetTransactor // Generic contract transactor binding to set the session for 10019 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 10020 } 10021 10022 // PauserRoleRenounceTargetRaw is an auto generated low-level Go binding around an Ethereum contract. 10023 type PauserRoleRenounceTargetRaw struct { 10024 Contract *PauserRoleRenounceTarget // Generic contract binding to access the raw methods on 10025 } 10026 10027 // PauserRoleRenounceTargetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 10028 type PauserRoleRenounceTargetCallerRaw struct { 10029 Contract *PauserRoleRenounceTargetCaller // Generic read-only contract binding to access the raw methods on 10030 } 10031 10032 // PauserRoleRenounceTargetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 10033 type PauserRoleRenounceTargetTransactorRaw struct { 10034 Contract *PauserRoleRenounceTargetTransactor // Generic write-only contract binding to access the raw methods on 10035 } 10036 10037 // NewPauserRoleRenounceTarget creates a new instance of PauserRoleRenounceTarget, bound to a specific deployed contract. 10038 func NewPauserRoleRenounceTarget(address common.Address, backend bind.ContractBackend) (*PauserRoleRenounceTarget, error) { 10039 contract, err := bindPauserRoleRenounceTarget(address, backend, backend, backend) 10040 if err != nil { 10041 return nil, err 10042 } 10043 return &PauserRoleRenounceTarget{PauserRoleRenounceTargetCaller: PauserRoleRenounceTargetCaller{contract: contract}, PauserRoleRenounceTargetTransactor: PauserRoleRenounceTargetTransactor{contract: contract}, PauserRoleRenounceTargetFilterer: PauserRoleRenounceTargetFilterer{contract: contract}}, nil 10044 } 10045 10046 // NewPauserRoleRenounceTargetCaller creates a new read-only instance of PauserRoleRenounceTarget, bound to a specific deployed contract. 10047 func NewPauserRoleRenounceTargetCaller(address common.Address, caller bind.ContractCaller) (*PauserRoleRenounceTargetCaller, error) { 10048 contract, err := bindPauserRoleRenounceTarget(address, caller, nil, nil) 10049 if err != nil { 10050 return nil, err 10051 } 10052 return &PauserRoleRenounceTargetCaller{contract: contract}, nil 10053 } 10054 10055 // NewPauserRoleRenounceTargetTransactor creates a new write-only instance of PauserRoleRenounceTarget, bound to a specific deployed contract. 10056 func NewPauserRoleRenounceTargetTransactor(address common.Address, transactor bind.ContractTransactor) (*PauserRoleRenounceTargetTransactor, error) { 10057 contract, err := bindPauserRoleRenounceTarget(address, nil, transactor, nil) 10058 if err != nil { 10059 return nil, err 10060 } 10061 return &PauserRoleRenounceTargetTransactor{contract: contract}, nil 10062 } 10063 10064 // NewPauserRoleRenounceTargetFilterer creates a new log filterer instance of PauserRoleRenounceTarget, bound to a specific deployed contract. 10065 func NewPauserRoleRenounceTargetFilterer(address common.Address, filterer bind.ContractFilterer) (*PauserRoleRenounceTargetFilterer, error) { 10066 contract, err := bindPauserRoleRenounceTarget(address, nil, nil, filterer) 10067 if err != nil { 10068 return nil, err 10069 } 10070 return &PauserRoleRenounceTargetFilterer{contract: contract}, nil 10071 } 10072 10073 // bindPauserRoleRenounceTarget binds a generic wrapper to an already deployed contract. 10074 func bindPauserRoleRenounceTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 10075 parsed, err := abi.JSON(strings.NewReader(PauserRoleRenounceTargetABI)) 10076 if err != nil { 10077 return nil, err 10078 } 10079 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 10080 } 10081 10082 // Call invokes the (constant) contract method with params as input values and 10083 // sets the output to result. The result type might be a single field for simple 10084 // returns, a slice of interfaces for anonymous returns and a struct for named 10085 // returns. 10086 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 10087 return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetCaller.contract.Call(opts, result, method, params...) 10088 } 10089 10090 // Transfer initiates a plain transaction to move funds to the contract, calling 10091 // its default method if one is available. 10092 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 10093 return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetTransactor.contract.Transfer(opts) 10094 } 10095 10096 // Transact invokes the (paid) contract method with params as input values. 10097 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 10098 return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetTransactor.contract.Transact(opts, method, params...) 10099 } 10100 10101 // Call invokes the (constant) contract method with params as input values and 10102 // sets the output to result. The result type might be a single field for simple 10103 // returns, a slice of interfaces for anonymous returns and a struct for named 10104 // returns. 10105 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 10106 return _PauserRoleRenounceTarget.Contract.contract.Call(opts, result, method, params...) 10107 } 10108 10109 // Transfer initiates a plain transaction to move funds to the contract, calling 10110 // its default method if one is available. 10111 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 10112 return _PauserRoleRenounceTarget.Contract.contract.Transfer(opts) 10113 } 10114 10115 // Transact invokes the (paid) contract method with params as input values. 10116 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 10117 return _PauserRoleRenounceTarget.Contract.contract.Transact(opts, method, params...) 10118 } 10119 10120 // RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d. 10121 // 10122 // Solidity: function renouncePauser() returns() 10123 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactor) RenouncePauser(opts *bind.TransactOpts) (*types.Transaction, error) { 10124 return _PauserRoleRenounceTarget.contract.Transact(opts, "renouncePauser") 10125 } 10126 10127 // RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d. 10128 // 10129 // Solidity: function renouncePauser() returns() 10130 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetSession) RenouncePauser() (*types.Transaction, error) { 10131 return _PauserRoleRenounceTarget.Contract.RenouncePauser(&_PauserRoleRenounceTarget.TransactOpts) 10132 } 10133 10134 // RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d. 10135 // 10136 // Solidity: function renouncePauser() returns() 10137 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorSession) RenouncePauser() (*types.Transaction, error) { 10138 return _PauserRoleRenounceTarget.Contract.RenouncePauser(&_PauserRoleRenounceTarget.TransactOpts) 10139 } 10140 10141 // ReentrancyGuardABI is the input ABI used to generate the binding from. 10142 const ReentrancyGuardABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]" 10143 10144 // ReentrancyGuard is an auto generated Go binding around an Ethereum contract. 10145 type ReentrancyGuard struct { 10146 ReentrancyGuardCaller // Read-only binding to the contract 10147 ReentrancyGuardTransactor // Write-only binding to the contract 10148 ReentrancyGuardFilterer // Log filterer for contract events 10149 } 10150 10151 // ReentrancyGuardCaller is an auto generated read-only Go binding around an Ethereum contract. 10152 type ReentrancyGuardCaller struct { 10153 contract *bind.BoundContract // Generic contract wrapper for the low level calls 10154 } 10155 10156 // ReentrancyGuardTransactor is an auto generated write-only Go binding around an Ethereum contract. 10157 type ReentrancyGuardTransactor struct { 10158 contract *bind.BoundContract // Generic contract wrapper for the low level calls 10159 } 10160 10161 // ReentrancyGuardFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 10162 type ReentrancyGuardFilterer struct { 10163 contract *bind.BoundContract // Generic contract wrapper for the low level calls 10164 } 10165 10166 // ReentrancyGuardSession is an auto generated Go binding around an Ethereum contract, 10167 // with pre-set call and transact options. 10168 type ReentrancyGuardSession struct { 10169 Contract *ReentrancyGuard // Generic contract binding to set the session for 10170 CallOpts bind.CallOpts // Call options to use throughout this session 10171 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 10172 } 10173 10174 // ReentrancyGuardCallerSession is an auto generated read-only Go binding around an Ethereum contract, 10175 // with pre-set call options. 10176 type ReentrancyGuardCallerSession struct { 10177 Contract *ReentrancyGuardCaller // Generic contract caller binding to set the session for 10178 CallOpts bind.CallOpts // Call options to use throughout this session 10179 } 10180 10181 // ReentrancyGuardTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 10182 // with pre-set transact options. 10183 type ReentrancyGuardTransactorSession struct { 10184 Contract *ReentrancyGuardTransactor // Generic contract transactor binding to set the session for 10185 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 10186 } 10187 10188 // ReentrancyGuardRaw is an auto generated low-level Go binding around an Ethereum contract. 10189 type ReentrancyGuardRaw struct { 10190 Contract *ReentrancyGuard // Generic contract binding to access the raw methods on 10191 } 10192 10193 // ReentrancyGuardCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 10194 type ReentrancyGuardCallerRaw struct { 10195 Contract *ReentrancyGuardCaller // Generic read-only contract binding to access the raw methods on 10196 } 10197 10198 // ReentrancyGuardTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 10199 type ReentrancyGuardTransactorRaw struct { 10200 Contract *ReentrancyGuardTransactor // Generic write-only contract binding to access the raw methods on 10201 } 10202 10203 // NewReentrancyGuard creates a new instance of ReentrancyGuard, bound to a specific deployed contract. 10204 func NewReentrancyGuard(address common.Address, backend bind.ContractBackend) (*ReentrancyGuard, error) { 10205 contract, err := bindReentrancyGuard(address, backend, backend, backend) 10206 if err != nil { 10207 return nil, err 10208 } 10209 return &ReentrancyGuard{ReentrancyGuardCaller: ReentrancyGuardCaller{contract: contract}, ReentrancyGuardTransactor: ReentrancyGuardTransactor{contract: contract}, ReentrancyGuardFilterer: ReentrancyGuardFilterer{contract: contract}}, nil 10210 } 10211 10212 // NewReentrancyGuardCaller creates a new read-only instance of ReentrancyGuard, bound to a specific deployed contract. 10213 func NewReentrancyGuardCaller(address common.Address, caller bind.ContractCaller) (*ReentrancyGuardCaller, error) { 10214 contract, err := bindReentrancyGuard(address, caller, nil, nil) 10215 if err != nil { 10216 return nil, err 10217 } 10218 return &ReentrancyGuardCaller{contract: contract}, nil 10219 } 10220 10221 // NewReentrancyGuardTransactor creates a new write-only instance of ReentrancyGuard, bound to a specific deployed contract. 10222 func NewReentrancyGuardTransactor(address common.Address, transactor bind.ContractTransactor) (*ReentrancyGuardTransactor, error) { 10223 contract, err := bindReentrancyGuard(address, nil, transactor, nil) 10224 if err != nil { 10225 return nil, err 10226 } 10227 return &ReentrancyGuardTransactor{contract: contract}, nil 10228 } 10229 10230 // NewReentrancyGuardFilterer creates a new log filterer instance of ReentrancyGuard, bound to a specific deployed contract. 10231 func NewReentrancyGuardFilterer(address common.Address, filterer bind.ContractFilterer) (*ReentrancyGuardFilterer, error) { 10232 contract, err := bindReentrancyGuard(address, nil, nil, filterer) 10233 if err != nil { 10234 return nil, err 10235 } 10236 return &ReentrancyGuardFilterer{contract: contract}, nil 10237 } 10238 10239 // bindReentrancyGuard binds a generic wrapper to an already deployed contract. 10240 func bindReentrancyGuard(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 10241 parsed, err := abi.JSON(strings.NewReader(ReentrancyGuardABI)) 10242 if err != nil { 10243 return nil, err 10244 } 10245 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 10246 } 10247 10248 // Call invokes the (constant) contract method with params as input values and 10249 // sets the output to result. The result type might be a single field for simple 10250 // returns, a slice of interfaces for anonymous returns and a struct for named 10251 // returns. 10252 func (_ReentrancyGuard *ReentrancyGuardRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 10253 return _ReentrancyGuard.Contract.ReentrancyGuardCaller.contract.Call(opts, result, method, params...) 10254 } 10255 10256 // Transfer initiates a plain transaction to move funds to the contract, calling 10257 // its default method if one is available. 10258 func (_ReentrancyGuard *ReentrancyGuardRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 10259 return _ReentrancyGuard.Contract.ReentrancyGuardTransactor.contract.Transfer(opts) 10260 } 10261 10262 // Transact invokes the (paid) contract method with params as input values. 10263 func (_ReentrancyGuard *ReentrancyGuardRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 10264 return _ReentrancyGuard.Contract.ReentrancyGuardTransactor.contract.Transact(opts, method, params...) 10265 } 10266 10267 // Call invokes the (constant) contract method with params as input values and 10268 // sets the output to result. The result type might be a single field for simple 10269 // returns, a slice of interfaces for anonymous returns and a struct for named 10270 // returns. 10271 func (_ReentrancyGuard *ReentrancyGuardCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 10272 return _ReentrancyGuard.Contract.contract.Call(opts, result, method, params...) 10273 } 10274 10275 // Transfer initiates a plain transaction to move funds to the contract, calling 10276 // its default method if one is available. 10277 func (_ReentrancyGuard *ReentrancyGuardTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 10278 return _ReentrancyGuard.Contract.contract.Transfer(opts) 10279 } 10280 10281 // Transact invokes the (paid) contract method with params as input values. 10282 func (_ReentrancyGuard *ReentrancyGuardTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 10283 return _ReentrancyGuard.Contract.contract.Transact(opts, method, params...) 10284 } 10285 10286 // RolesABI is the input ABI used to generate the binding from. 10287 const RolesABI = "[]" 10288 10289 // RolesBin is the compiled bytecode used for deploying new contracts. 10290 var RolesBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a72315820451a2112c879141f72bbe0ec00d853511a9d98646af7e3081d90a3d70270eb1564736f6c634300050c0032" 10291 10292 // DeployRoles deploys a new Ethereum contract, binding an instance of Roles to it. 10293 func DeployRoles(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Roles, error) { 10294 parsed, err := abi.JSON(strings.NewReader(RolesABI)) 10295 if err != nil { 10296 return common.Address{}, nil, nil, err 10297 } 10298 10299 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(RolesBin), backend) 10300 if err != nil { 10301 return common.Address{}, nil, nil, err 10302 } 10303 return address, tx, &Roles{RolesCaller: RolesCaller{contract: contract}, RolesTransactor: RolesTransactor{contract: contract}, RolesFilterer: RolesFilterer{contract: contract}}, nil 10304 } 10305 10306 // Roles is an auto generated Go binding around an Ethereum contract. 10307 type Roles struct { 10308 RolesCaller // Read-only binding to the contract 10309 RolesTransactor // Write-only binding to the contract 10310 RolesFilterer // Log filterer for contract events 10311 } 10312 10313 // RolesCaller is an auto generated read-only Go binding around an Ethereum contract. 10314 type RolesCaller struct { 10315 contract *bind.BoundContract // Generic contract wrapper for the low level calls 10316 } 10317 10318 // RolesTransactor is an auto generated write-only Go binding around an Ethereum contract. 10319 type RolesTransactor struct { 10320 contract *bind.BoundContract // Generic contract wrapper for the low level calls 10321 } 10322 10323 // RolesFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 10324 type RolesFilterer struct { 10325 contract *bind.BoundContract // Generic contract wrapper for the low level calls 10326 } 10327 10328 // RolesSession is an auto generated Go binding around an Ethereum contract, 10329 // with pre-set call and transact options. 10330 type RolesSession struct { 10331 Contract *Roles // Generic contract binding to set the session for 10332 CallOpts bind.CallOpts // Call options to use throughout this session 10333 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 10334 } 10335 10336 // RolesCallerSession is an auto generated read-only Go binding around an Ethereum contract, 10337 // with pre-set call options. 10338 type RolesCallerSession struct { 10339 Contract *RolesCaller // Generic contract caller binding to set the session for 10340 CallOpts bind.CallOpts // Call options to use throughout this session 10341 } 10342 10343 // RolesTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 10344 // with pre-set transact options. 10345 type RolesTransactorSession struct { 10346 Contract *RolesTransactor // Generic contract transactor binding to set the session for 10347 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 10348 } 10349 10350 // RolesRaw is an auto generated low-level Go binding around an Ethereum contract. 10351 type RolesRaw struct { 10352 Contract *Roles // Generic contract binding to access the raw methods on 10353 } 10354 10355 // RolesCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 10356 type RolesCallerRaw struct { 10357 Contract *RolesCaller // Generic read-only contract binding to access the raw methods on 10358 } 10359 10360 // RolesTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 10361 type RolesTransactorRaw struct { 10362 Contract *RolesTransactor // Generic write-only contract binding to access the raw methods on 10363 } 10364 10365 // NewRoles creates a new instance of Roles, bound to a specific deployed contract. 10366 func NewRoles(address common.Address, backend bind.ContractBackend) (*Roles, error) { 10367 contract, err := bindRoles(address, backend, backend, backend) 10368 if err != nil { 10369 return nil, err 10370 } 10371 return &Roles{RolesCaller: RolesCaller{contract: contract}, RolesTransactor: RolesTransactor{contract: contract}, RolesFilterer: RolesFilterer{contract: contract}}, nil 10372 } 10373 10374 // NewRolesCaller creates a new read-only instance of Roles, bound to a specific deployed contract. 10375 func NewRolesCaller(address common.Address, caller bind.ContractCaller) (*RolesCaller, error) { 10376 contract, err := bindRoles(address, caller, nil, nil) 10377 if err != nil { 10378 return nil, err 10379 } 10380 return &RolesCaller{contract: contract}, nil 10381 } 10382 10383 // NewRolesTransactor creates a new write-only instance of Roles, bound to a specific deployed contract. 10384 func NewRolesTransactor(address common.Address, transactor bind.ContractTransactor) (*RolesTransactor, error) { 10385 contract, err := bindRoles(address, nil, transactor, nil) 10386 if err != nil { 10387 return nil, err 10388 } 10389 return &RolesTransactor{contract: contract}, nil 10390 } 10391 10392 // NewRolesFilterer creates a new log filterer instance of Roles, bound to a specific deployed contract. 10393 func NewRolesFilterer(address common.Address, filterer bind.ContractFilterer) (*RolesFilterer, error) { 10394 contract, err := bindRoles(address, nil, nil, filterer) 10395 if err != nil { 10396 return nil, err 10397 } 10398 return &RolesFilterer{contract: contract}, nil 10399 } 10400 10401 // bindRoles binds a generic wrapper to an already deployed contract. 10402 func bindRoles(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 10403 parsed, err := abi.JSON(strings.NewReader(RolesABI)) 10404 if err != nil { 10405 return nil, err 10406 } 10407 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 10408 } 10409 10410 // Call invokes the (constant) contract method with params as input values and 10411 // sets the output to result. The result type might be a single field for simple 10412 // returns, a slice of interfaces for anonymous returns and a struct for named 10413 // returns. 10414 func (_Roles *RolesRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 10415 return _Roles.Contract.RolesCaller.contract.Call(opts, result, method, params...) 10416 } 10417 10418 // Transfer initiates a plain transaction to move funds to the contract, calling 10419 // its default method if one is available. 10420 func (_Roles *RolesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 10421 return _Roles.Contract.RolesTransactor.contract.Transfer(opts) 10422 } 10423 10424 // Transact invokes the (paid) contract method with params as input values. 10425 func (_Roles *RolesRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 10426 return _Roles.Contract.RolesTransactor.contract.Transact(opts, method, params...) 10427 } 10428 10429 // Call invokes the (constant) contract method with params as input values and 10430 // sets the output to result. The result type might be a single field for simple 10431 // returns, a slice of interfaces for anonymous returns and a struct for named 10432 // returns. 10433 func (_Roles *RolesCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 10434 return _Roles.Contract.contract.Call(opts, result, method, params...) 10435 } 10436 10437 // Transfer initiates a plain transaction to move funds to the contract, calling 10438 // its default method if one is available. 10439 func (_Roles *RolesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 10440 return _Roles.Contract.contract.Transfer(opts) 10441 } 10442 10443 // Transact invokes the (paid) contract method with params as input values. 10444 func (_Roles *RolesTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 10445 return _Roles.Contract.contract.Transact(opts, method, params...) 10446 } 10447 10448 // RootChainIABI is the input ABI used to generate the binding from. 10449 const RootChainIABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"currentFork\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"isRootChain\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"forkNumber\",\"type\":\"uint256\"}],\"name\":\"lastEpoch\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"operator\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]" 10450 10451 // RootChainIFuncSigs maps the 4-byte function signature to its string representation. 10452 var RootChainIFuncSigs = map[string]string{ 10453 "183d2d1c": "currentFork()", 10454 "420bb4b8": "isRootChain()", 10455 "11e4c914": "lastEpoch(uint256)", 10456 "570ca735": "operator()", 10457 } 10458 10459 // RootChainI is an auto generated Go binding around an Ethereum contract. 10460 type RootChainI struct { 10461 RootChainICaller // Read-only binding to the contract 10462 RootChainITransactor // Write-only binding to the contract 10463 RootChainIFilterer // Log filterer for contract events 10464 } 10465 10466 // RootChainICaller is an auto generated read-only Go binding around an Ethereum contract. 10467 type RootChainICaller struct { 10468 contract *bind.BoundContract // Generic contract wrapper for the low level calls 10469 } 10470 10471 // RootChainITransactor is an auto generated write-only Go binding around an Ethereum contract. 10472 type RootChainITransactor struct { 10473 contract *bind.BoundContract // Generic contract wrapper for the low level calls 10474 } 10475 10476 // RootChainIFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 10477 type RootChainIFilterer struct { 10478 contract *bind.BoundContract // Generic contract wrapper for the low level calls 10479 } 10480 10481 // RootChainISession is an auto generated Go binding around an Ethereum contract, 10482 // with pre-set call and transact options. 10483 type RootChainISession struct { 10484 Contract *RootChainI // Generic contract binding to set the session for 10485 CallOpts bind.CallOpts // Call options to use throughout this session 10486 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 10487 } 10488 10489 // RootChainICallerSession is an auto generated read-only Go binding around an Ethereum contract, 10490 // with pre-set call options. 10491 type RootChainICallerSession struct { 10492 Contract *RootChainICaller // Generic contract caller binding to set the session for 10493 CallOpts bind.CallOpts // Call options to use throughout this session 10494 } 10495 10496 // RootChainITransactorSession is an auto generated write-only Go binding around an Ethereum contract, 10497 // with pre-set transact options. 10498 type RootChainITransactorSession struct { 10499 Contract *RootChainITransactor // Generic contract transactor binding to set the session for 10500 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 10501 } 10502 10503 // RootChainIRaw is an auto generated low-level Go binding around an Ethereum contract. 10504 type RootChainIRaw struct { 10505 Contract *RootChainI // Generic contract binding to access the raw methods on 10506 } 10507 10508 // RootChainICallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 10509 type RootChainICallerRaw struct { 10510 Contract *RootChainICaller // Generic read-only contract binding to access the raw methods on 10511 } 10512 10513 // RootChainITransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 10514 type RootChainITransactorRaw struct { 10515 Contract *RootChainITransactor // Generic write-only contract binding to access the raw methods on 10516 } 10517 10518 // NewRootChainI creates a new instance of RootChainI, bound to a specific deployed contract. 10519 func NewRootChainI(address common.Address, backend bind.ContractBackend) (*RootChainI, error) { 10520 contract, err := bindRootChainI(address, backend, backend, backend) 10521 if err != nil { 10522 return nil, err 10523 } 10524 return &RootChainI{RootChainICaller: RootChainICaller{contract: contract}, RootChainITransactor: RootChainITransactor{contract: contract}, RootChainIFilterer: RootChainIFilterer{contract: contract}}, nil 10525 } 10526 10527 // NewRootChainICaller creates a new read-only instance of RootChainI, bound to a specific deployed contract. 10528 func NewRootChainICaller(address common.Address, caller bind.ContractCaller) (*RootChainICaller, error) { 10529 contract, err := bindRootChainI(address, caller, nil, nil) 10530 if err != nil { 10531 return nil, err 10532 } 10533 return &RootChainICaller{contract: contract}, nil 10534 } 10535 10536 // NewRootChainITransactor creates a new write-only instance of RootChainI, bound to a specific deployed contract. 10537 func NewRootChainITransactor(address common.Address, transactor bind.ContractTransactor) (*RootChainITransactor, error) { 10538 contract, err := bindRootChainI(address, nil, transactor, nil) 10539 if err != nil { 10540 return nil, err 10541 } 10542 return &RootChainITransactor{contract: contract}, nil 10543 } 10544 10545 // NewRootChainIFilterer creates a new log filterer instance of RootChainI, bound to a specific deployed contract. 10546 func NewRootChainIFilterer(address common.Address, filterer bind.ContractFilterer) (*RootChainIFilterer, error) { 10547 contract, err := bindRootChainI(address, nil, nil, filterer) 10548 if err != nil { 10549 return nil, err 10550 } 10551 return &RootChainIFilterer{contract: contract}, nil 10552 } 10553 10554 // bindRootChainI binds a generic wrapper to an already deployed contract. 10555 func bindRootChainI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 10556 parsed, err := abi.JSON(strings.NewReader(RootChainIABI)) 10557 if err != nil { 10558 return nil, err 10559 } 10560 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 10561 } 10562 10563 // Call invokes the (constant) contract method with params as input values and 10564 // sets the output to result. The result type might be a single field for simple 10565 // returns, a slice of interfaces for anonymous returns and a struct for named 10566 // returns. 10567 func (_RootChainI *RootChainIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 10568 return _RootChainI.Contract.RootChainICaller.contract.Call(opts, result, method, params...) 10569 } 10570 10571 // Transfer initiates a plain transaction to move funds to the contract, calling 10572 // its default method if one is available. 10573 func (_RootChainI *RootChainIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 10574 return _RootChainI.Contract.RootChainITransactor.contract.Transfer(opts) 10575 } 10576 10577 // Transact invokes the (paid) contract method with params as input values. 10578 func (_RootChainI *RootChainIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 10579 return _RootChainI.Contract.RootChainITransactor.contract.Transact(opts, method, params...) 10580 } 10581 10582 // Call invokes the (constant) contract method with params as input values and 10583 // sets the output to result. The result type might be a single field for simple 10584 // returns, a slice of interfaces for anonymous returns and a struct for named 10585 // returns. 10586 func (_RootChainI *RootChainICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 10587 return _RootChainI.Contract.contract.Call(opts, result, method, params...) 10588 } 10589 10590 // Transfer initiates a plain transaction to move funds to the contract, calling 10591 // its default method if one is available. 10592 func (_RootChainI *RootChainITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 10593 return _RootChainI.Contract.contract.Transfer(opts) 10594 } 10595 10596 // Transact invokes the (paid) contract method with params as input values. 10597 func (_RootChainI *RootChainITransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 10598 return _RootChainI.Contract.contract.Transact(opts, method, params...) 10599 } 10600 10601 // CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c. 10602 // 10603 // Solidity: function currentFork() constant returns(uint256) 10604 func (_RootChainI *RootChainICaller) CurrentFork(opts *bind.CallOpts) (*big.Int, error) { 10605 var ( 10606 ret0 = new(*big.Int) 10607 ) 10608 out := ret0 10609 err := _RootChainI.contract.Call(opts, out, "currentFork") 10610 return *ret0, err 10611 } 10612 10613 // CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c. 10614 // 10615 // Solidity: function currentFork() constant returns(uint256) 10616 func (_RootChainI *RootChainISession) CurrentFork() (*big.Int, error) { 10617 return _RootChainI.Contract.CurrentFork(&_RootChainI.CallOpts) 10618 } 10619 10620 // CurrentFork is a free data retrieval call binding the contract method 0x183d2d1c. 10621 // 10622 // Solidity: function currentFork() constant returns(uint256) 10623 func (_RootChainI *RootChainICallerSession) CurrentFork() (*big.Int, error) { 10624 return _RootChainI.Contract.CurrentFork(&_RootChainI.CallOpts) 10625 } 10626 10627 // IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8. 10628 // 10629 // Solidity: function isRootChain() constant returns(bool) 10630 func (_RootChainI *RootChainICaller) IsRootChain(opts *bind.CallOpts) (bool, error) { 10631 var ( 10632 ret0 = new(bool) 10633 ) 10634 out := ret0 10635 err := _RootChainI.contract.Call(opts, out, "isRootChain") 10636 return *ret0, err 10637 } 10638 10639 // IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8. 10640 // 10641 // Solidity: function isRootChain() constant returns(bool) 10642 func (_RootChainI *RootChainISession) IsRootChain() (bool, error) { 10643 return _RootChainI.Contract.IsRootChain(&_RootChainI.CallOpts) 10644 } 10645 10646 // IsRootChain is a free data retrieval call binding the contract method 0x420bb4b8. 10647 // 10648 // Solidity: function isRootChain() constant returns(bool) 10649 func (_RootChainI *RootChainICallerSession) IsRootChain() (bool, error) { 10650 return _RootChainI.Contract.IsRootChain(&_RootChainI.CallOpts) 10651 } 10652 10653 // LastEpoch is a free data retrieval call binding the contract method 0x11e4c914. 10654 // 10655 // Solidity: function lastEpoch(uint256 forkNumber) constant returns(uint256) 10656 func (_RootChainI *RootChainICaller) LastEpoch(opts *bind.CallOpts, forkNumber *big.Int) (*big.Int, error) { 10657 var ( 10658 ret0 = new(*big.Int) 10659 ) 10660 out := ret0 10661 err := _RootChainI.contract.Call(opts, out, "lastEpoch", forkNumber) 10662 return *ret0, err 10663 } 10664 10665 // LastEpoch is a free data retrieval call binding the contract method 0x11e4c914. 10666 // 10667 // Solidity: function lastEpoch(uint256 forkNumber) constant returns(uint256) 10668 func (_RootChainI *RootChainISession) LastEpoch(forkNumber *big.Int) (*big.Int, error) { 10669 return _RootChainI.Contract.LastEpoch(&_RootChainI.CallOpts, forkNumber) 10670 } 10671 10672 // LastEpoch is a free data retrieval call binding the contract method 0x11e4c914. 10673 // 10674 // Solidity: function lastEpoch(uint256 forkNumber) constant returns(uint256) 10675 func (_RootChainI *RootChainICallerSession) LastEpoch(forkNumber *big.Int) (*big.Int, error) { 10676 return _RootChainI.Contract.LastEpoch(&_RootChainI.CallOpts, forkNumber) 10677 } 10678 10679 // Operator is a free data retrieval call binding the contract method 0x570ca735. 10680 // 10681 // Solidity: function operator() constant returns(address) 10682 func (_RootChainI *RootChainICaller) Operator(opts *bind.CallOpts) (common.Address, error) { 10683 var ( 10684 ret0 = new(common.Address) 10685 ) 10686 out := ret0 10687 err := _RootChainI.contract.Call(opts, out, "operator") 10688 return *ret0, err 10689 } 10690 10691 // Operator is a free data retrieval call binding the contract method 0x570ca735. 10692 // 10693 // Solidity: function operator() constant returns(address) 10694 func (_RootChainI *RootChainISession) Operator() (common.Address, error) { 10695 return _RootChainI.Contract.Operator(&_RootChainI.CallOpts) 10696 } 10697 10698 // Operator is a free data retrieval call binding the contract method 0x570ca735. 10699 // 10700 // Solidity: function operator() constant returns(address) 10701 func (_RootChainI *RootChainICallerSession) Operator() (common.Address, error) { 10702 return _RootChainI.Contract.Operator(&_RootChainI.CallOpts) 10703 } 10704 10705 // RootChainRegistryIABI is the input ABI used to generate the binding from. 10706 const RootChainRegistryIABI = "[{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"seigManager\",\"type\":\"address\"}],\"name\":\"deployCoinage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"numRootChains\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"register\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"seigManager\",\"type\":\"address\"}],\"name\":\"registerAndDeployCoinage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"index\",\"type\":\"uint256\"}],\"name\":\"rootchainByIndex\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"rootchains\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"unregister\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 10707 10708 // RootChainRegistryIFuncSigs maps the 4-byte function signature to its string representation. 10709 var RootChainRegistryIFuncSigs = map[string]string{ 10710 "85108604": "deployCoinage(address,address)", 10711 "b2b604d0": "numRootChains()", 10712 "4420e486": "register(address)", 10713 "bcb1a71e": "registerAndDeployCoinage(address,address)", 10714 "821f602c": "rootchainByIndex(uint256)", 10715 "02a15299": "rootchains(address)", 10716 "2ec2c246": "unregister(address)", 10717 } 10718 10719 // RootChainRegistryI is an auto generated Go binding around an Ethereum contract. 10720 type RootChainRegistryI struct { 10721 RootChainRegistryICaller // Read-only binding to the contract 10722 RootChainRegistryITransactor // Write-only binding to the contract 10723 RootChainRegistryIFilterer // Log filterer for contract events 10724 } 10725 10726 // RootChainRegistryICaller is an auto generated read-only Go binding around an Ethereum contract. 10727 type RootChainRegistryICaller struct { 10728 contract *bind.BoundContract // Generic contract wrapper for the low level calls 10729 } 10730 10731 // RootChainRegistryITransactor is an auto generated write-only Go binding around an Ethereum contract. 10732 type RootChainRegistryITransactor struct { 10733 contract *bind.BoundContract // Generic contract wrapper for the low level calls 10734 } 10735 10736 // RootChainRegistryIFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 10737 type RootChainRegistryIFilterer struct { 10738 contract *bind.BoundContract // Generic contract wrapper for the low level calls 10739 } 10740 10741 // RootChainRegistryISession is an auto generated Go binding around an Ethereum contract, 10742 // with pre-set call and transact options. 10743 type RootChainRegistryISession struct { 10744 Contract *RootChainRegistryI // Generic contract binding to set the session for 10745 CallOpts bind.CallOpts // Call options to use throughout this session 10746 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 10747 } 10748 10749 // RootChainRegistryICallerSession is an auto generated read-only Go binding around an Ethereum contract, 10750 // with pre-set call options. 10751 type RootChainRegistryICallerSession struct { 10752 Contract *RootChainRegistryICaller // Generic contract caller binding to set the session for 10753 CallOpts bind.CallOpts // Call options to use throughout this session 10754 } 10755 10756 // RootChainRegistryITransactorSession is an auto generated write-only Go binding around an Ethereum contract, 10757 // with pre-set transact options. 10758 type RootChainRegistryITransactorSession struct { 10759 Contract *RootChainRegistryITransactor // Generic contract transactor binding to set the session for 10760 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 10761 } 10762 10763 // RootChainRegistryIRaw is an auto generated low-level Go binding around an Ethereum contract. 10764 type RootChainRegistryIRaw struct { 10765 Contract *RootChainRegistryI // Generic contract binding to access the raw methods on 10766 } 10767 10768 // RootChainRegistryICallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 10769 type RootChainRegistryICallerRaw struct { 10770 Contract *RootChainRegistryICaller // Generic read-only contract binding to access the raw methods on 10771 } 10772 10773 // RootChainRegistryITransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 10774 type RootChainRegistryITransactorRaw struct { 10775 Contract *RootChainRegistryITransactor // Generic write-only contract binding to access the raw methods on 10776 } 10777 10778 // NewRootChainRegistryI creates a new instance of RootChainRegistryI, bound to a specific deployed contract. 10779 func NewRootChainRegistryI(address common.Address, backend bind.ContractBackend) (*RootChainRegistryI, error) { 10780 contract, err := bindRootChainRegistryI(address, backend, backend, backend) 10781 if err != nil { 10782 return nil, err 10783 } 10784 return &RootChainRegistryI{RootChainRegistryICaller: RootChainRegistryICaller{contract: contract}, RootChainRegistryITransactor: RootChainRegistryITransactor{contract: contract}, RootChainRegistryIFilterer: RootChainRegistryIFilterer{contract: contract}}, nil 10785 } 10786 10787 // NewRootChainRegistryICaller creates a new read-only instance of RootChainRegistryI, bound to a specific deployed contract. 10788 func NewRootChainRegistryICaller(address common.Address, caller bind.ContractCaller) (*RootChainRegistryICaller, error) { 10789 contract, err := bindRootChainRegistryI(address, caller, nil, nil) 10790 if err != nil { 10791 return nil, err 10792 } 10793 return &RootChainRegistryICaller{contract: contract}, nil 10794 } 10795 10796 // NewRootChainRegistryITransactor creates a new write-only instance of RootChainRegistryI, bound to a specific deployed contract. 10797 func NewRootChainRegistryITransactor(address common.Address, transactor bind.ContractTransactor) (*RootChainRegistryITransactor, error) { 10798 contract, err := bindRootChainRegistryI(address, nil, transactor, nil) 10799 if err != nil { 10800 return nil, err 10801 } 10802 return &RootChainRegistryITransactor{contract: contract}, nil 10803 } 10804 10805 // NewRootChainRegistryIFilterer creates a new log filterer instance of RootChainRegistryI, bound to a specific deployed contract. 10806 func NewRootChainRegistryIFilterer(address common.Address, filterer bind.ContractFilterer) (*RootChainRegistryIFilterer, error) { 10807 contract, err := bindRootChainRegistryI(address, nil, nil, filterer) 10808 if err != nil { 10809 return nil, err 10810 } 10811 return &RootChainRegistryIFilterer{contract: contract}, nil 10812 } 10813 10814 // bindRootChainRegistryI binds a generic wrapper to an already deployed contract. 10815 func bindRootChainRegistryI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 10816 parsed, err := abi.JSON(strings.NewReader(RootChainRegistryIABI)) 10817 if err != nil { 10818 return nil, err 10819 } 10820 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 10821 } 10822 10823 // Call invokes the (constant) contract method with params as input values and 10824 // sets the output to result. The result type might be a single field for simple 10825 // returns, a slice of interfaces for anonymous returns and a struct for named 10826 // returns. 10827 func (_RootChainRegistryI *RootChainRegistryIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 10828 return _RootChainRegistryI.Contract.RootChainRegistryICaller.contract.Call(opts, result, method, params...) 10829 } 10830 10831 // Transfer initiates a plain transaction to move funds to the contract, calling 10832 // its default method if one is available. 10833 func (_RootChainRegistryI *RootChainRegistryIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 10834 return _RootChainRegistryI.Contract.RootChainRegistryITransactor.contract.Transfer(opts) 10835 } 10836 10837 // Transact invokes the (paid) contract method with params as input values. 10838 func (_RootChainRegistryI *RootChainRegistryIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 10839 return _RootChainRegistryI.Contract.RootChainRegistryITransactor.contract.Transact(opts, method, params...) 10840 } 10841 10842 // Call invokes the (constant) contract method with params as input values and 10843 // sets the output to result. The result type might be a single field for simple 10844 // returns, a slice of interfaces for anonymous returns and a struct for named 10845 // returns. 10846 func (_RootChainRegistryI *RootChainRegistryICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 10847 return _RootChainRegistryI.Contract.contract.Call(opts, result, method, params...) 10848 } 10849 10850 // Transfer initiates a plain transaction to move funds to the contract, calling 10851 // its default method if one is available. 10852 func (_RootChainRegistryI *RootChainRegistryITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 10853 return _RootChainRegistryI.Contract.contract.Transfer(opts) 10854 } 10855 10856 // Transact invokes the (paid) contract method with params as input values. 10857 func (_RootChainRegistryI *RootChainRegistryITransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 10858 return _RootChainRegistryI.Contract.contract.Transact(opts, method, params...) 10859 } 10860 10861 // NumRootChains is a free data retrieval call binding the contract method 0xb2b604d0. 10862 // 10863 // Solidity: function numRootChains() constant returns(uint256) 10864 func (_RootChainRegistryI *RootChainRegistryICaller) NumRootChains(opts *bind.CallOpts) (*big.Int, error) { 10865 var ( 10866 ret0 = new(*big.Int) 10867 ) 10868 out := ret0 10869 err := _RootChainRegistryI.contract.Call(opts, out, "numRootChains") 10870 return *ret0, err 10871 } 10872 10873 // NumRootChains is a free data retrieval call binding the contract method 0xb2b604d0. 10874 // 10875 // Solidity: function numRootChains() constant returns(uint256) 10876 func (_RootChainRegistryI *RootChainRegistryISession) NumRootChains() (*big.Int, error) { 10877 return _RootChainRegistryI.Contract.NumRootChains(&_RootChainRegistryI.CallOpts) 10878 } 10879 10880 // NumRootChains is a free data retrieval call binding the contract method 0xb2b604d0. 10881 // 10882 // Solidity: function numRootChains() constant returns(uint256) 10883 func (_RootChainRegistryI *RootChainRegistryICallerSession) NumRootChains() (*big.Int, error) { 10884 return _RootChainRegistryI.Contract.NumRootChains(&_RootChainRegistryI.CallOpts) 10885 } 10886 10887 // RootchainByIndex is a free data retrieval call binding the contract method 0x821f602c. 10888 // 10889 // Solidity: function rootchainByIndex(uint256 index) constant returns(address) 10890 func (_RootChainRegistryI *RootChainRegistryICaller) RootchainByIndex(opts *bind.CallOpts, index *big.Int) (common.Address, error) { 10891 var ( 10892 ret0 = new(common.Address) 10893 ) 10894 out := ret0 10895 err := _RootChainRegistryI.contract.Call(opts, out, "rootchainByIndex", index) 10896 return *ret0, err 10897 } 10898 10899 // RootchainByIndex is a free data retrieval call binding the contract method 0x821f602c. 10900 // 10901 // Solidity: function rootchainByIndex(uint256 index) constant returns(address) 10902 func (_RootChainRegistryI *RootChainRegistryISession) RootchainByIndex(index *big.Int) (common.Address, error) { 10903 return _RootChainRegistryI.Contract.RootchainByIndex(&_RootChainRegistryI.CallOpts, index) 10904 } 10905 10906 // RootchainByIndex is a free data retrieval call binding the contract method 0x821f602c. 10907 // 10908 // Solidity: function rootchainByIndex(uint256 index) constant returns(address) 10909 func (_RootChainRegistryI *RootChainRegistryICallerSession) RootchainByIndex(index *big.Int) (common.Address, error) { 10910 return _RootChainRegistryI.Contract.RootchainByIndex(&_RootChainRegistryI.CallOpts, index) 10911 } 10912 10913 // Rootchains is a free data retrieval call binding the contract method 0x02a15299. 10914 // 10915 // Solidity: function rootchains(address rootchain) constant returns(bool) 10916 func (_RootChainRegistryI *RootChainRegistryICaller) Rootchains(opts *bind.CallOpts, rootchain common.Address) (bool, error) { 10917 var ( 10918 ret0 = new(bool) 10919 ) 10920 out := ret0 10921 err := _RootChainRegistryI.contract.Call(opts, out, "rootchains", rootchain) 10922 return *ret0, err 10923 } 10924 10925 // Rootchains is a free data retrieval call binding the contract method 0x02a15299. 10926 // 10927 // Solidity: function rootchains(address rootchain) constant returns(bool) 10928 func (_RootChainRegistryI *RootChainRegistryISession) Rootchains(rootchain common.Address) (bool, error) { 10929 return _RootChainRegistryI.Contract.Rootchains(&_RootChainRegistryI.CallOpts, rootchain) 10930 } 10931 10932 // Rootchains is a free data retrieval call binding the contract method 0x02a15299. 10933 // 10934 // Solidity: function rootchains(address rootchain) constant returns(bool) 10935 func (_RootChainRegistryI *RootChainRegistryICallerSession) Rootchains(rootchain common.Address) (bool, error) { 10936 return _RootChainRegistryI.Contract.Rootchains(&_RootChainRegistryI.CallOpts, rootchain) 10937 } 10938 10939 // DeployCoinage is a paid mutator transaction binding the contract method 0x85108604. 10940 // 10941 // Solidity: function deployCoinage(address rootchain, address seigManager) returns(bool) 10942 func (_RootChainRegistryI *RootChainRegistryITransactor) DeployCoinage(opts *bind.TransactOpts, rootchain common.Address, seigManager common.Address) (*types.Transaction, error) { 10943 return _RootChainRegistryI.contract.Transact(opts, "deployCoinage", rootchain, seigManager) 10944 } 10945 10946 // DeployCoinage is a paid mutator transaction binding the contract method 0x85108604. 10947 // 10948 // Solidity: function deployCoinage(address rootchain, address seigManager) returns(bool) 10949 func (_RootChainRegistryI *RootChainRegistryISession) DeployCoinage(rootchain common.Address, seigManager common.Address) (*types.Transaction, error) { 10950 return _RootChainRegistryI.Contract.DeployCoinage(&_RootChainRegistryI.TransactOpts, rootchain, seigManager) 10951 } 10952 10953 // DeployCoinage is a paid mutator transaction binding the contract method 0x85108604. 10954 // 10955 // Solidity: function deployCoinage(address rootchain, address seigManager) returns(bool) 10956 func (_RootChainRegistryI *RootChainRegistryITransactorSession) DeployCoinage(rootchain common.Address, seigManager common.Address) (*types.Transaction, error) { 10957 return _RootChainRegistryI.Contract.DeployCoinage(&_RootChainRegistryI.TransactOpts, rootchain, seigManager) 10958 } 10959 10960 // Register is a paid mutator transaction binding the contract method 0x4420e486. 10961 // 10962 // Solidity: function register(address rootchain) returns(bool) 10963 func (_RootChainRegistryI *RootChainRegistryITransactor) Register(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) { 10964 return _RootChainRegistryI.contract.Transact(opts, "register", rootchain) 10965 } 10966 10967 // Register is a paid mutator transaction binding the contract method 0x4420e486. 10968 // 10969 // Solidity: function register(address rootchain) returns(bool) 10970 func (_RootChainRegistryI *RootChainRegistryISession) Register(rootchain common.Address) (*types.Transaction, error) { 10971 return _RootChainRegistryI.Contract.Register(&_RootChainRegistryI.TransactOpts, rootchain) 10972 } 10973 10974 // Register is a paid mutator transaction binding the contract method 0x4420e486. 10975 // 10976 // Solidity: function register(address rootchain) returns(bool) 10977 func (_RootChainRegistryI *RootChainRegistryITransactorSession) Register(rootchain common.Address) (*types.Transaction, error) { 10978 return _RootChainRegistryI.Contract.Register(&_RootChainRegistryI.TransactOpts, rootchain) 10979 } 10980 10981 // RegisterAndDeployCoinage is a paid mutator transaction binding the contract method 0xbcb1a71e. 10982 // 10983 // Solidity: function registerAndDeployCoinage(address rootchain, address seigManager) returns(bool) 10984 func (_RootChainRegistryI *RootChainRegistryITransactor) RegisterAndDeployCoinage(opts *bind.TransactOpts, rootchain common.Address, seigManager common.Address) (*types.Transaction, error) { 10985 return _RootChainRegistryI.contract.Transact(opts, "registerAndDeployCoinage", rootchain, seigManager) 10986 } 10987 10988 // RegisterAndDeployCoinage is a paid mutator transaction binding the contract method 0xbcb1a71e. 10989 // 10990 // Solidity: function registerAndDeployCoinage(address rootchain, address seigManager) returns(bool) 10991 func (_RootChainRegistryI *RootChainRegistryISession) RegisterAndDeployCoinage(rootchain common.Address, seigManager common.Address) (*types.Transaction, error) { 10992 return _RootChainRegistryI.Contract.RegisterAndDeployCoinage(&_RootChainRegistryI.TransactOpts, rootchain, seigManager) 10993 } 10994 10995 // RegisterAndDeployCoinage is a paid mutator transaction binding the contract method 0xbcb1a71e. 10996 // 10997 // Solidity: function registerAndDeployCoinage(address rootchain, address seigManager) returns(bool) 10998 func (_RootChainRegistryI *RootChainRegistryITransactorSession) RegisterAndDeployCoinage(rootchain common.Address, seigManager common.Address) (*types.Transaction, error) { 10999 return _RootChainRegistryI.Contract.RegisterAndDeployCoinage(&_RootChainRegistryI.TransactOpts, rootchain, seigManager) 11000 } 11001 11002 // Unregister is a paid mutator transaction binding the contract method 0x2ec2c246. 11003 // 11004 // Solidity: function unregister(address rootchain) returns(bool) 11005 func (_RootChainRegistryI *RootChainRegistryITransactor) Unregister(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) { 11006 return _RootChainRegistryI.contract.Transact(opts, "unregister", rootchain) 11007 } 11008 11009 // Unregister is a paid mutator transaction binding the contract method 0x2ec2c246. 11010 // 11011 // Solidity: function unregister(address rootchain) returns(bool) 11012 func (_RootChainRegistryI *RootChainRegistryISession) Unregister(rootchain common.Address) (*types.Transaction, error) { 11013 return _RootChainRegistryI.Contract.Unregister(&_RootChainRegistryI.TransactOpts, rootchain) 11014 } 11015 11016 // Unregister is a paid mutator transaction binding the contract method 0x2ec2c246. 11017 // 11018 // Solidity: function unregister(address rootchain) returns(bool) 11019 func (_RootChainRegistryI *RootChainRegistryITransactorSession) Unregister(rootchain common.Address) (*types.Transaction, error) { 11020 return _RootChainRegistryI.Contract.Unregister(&_RootChainRegistryI.TransactOpts, rootchain) 11021 } 11022 11023 // SafeERC20ABI is the input ABI used to generate the binding from. 11024 const SafeERC20ABI = "[]" 11025 11026 // SafeERC20Bin is the compiled bytecode used for deploying new contracts. 11027 var SafeERC20Bin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582045a04cb654e4c37bcd57cef5b1e4313fd04e0fbb06c03b04321592cfa5eb149764736f6c634300050c0032" 11028 11029 // DeploySafeERC20 deploys a new Ethereum contract, binding an instance of SafeERC20 to it. 11030 func DeploySafeERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeERC20, error) { 11031 parsed, err := abi.JSON(strings.NewReader(SafeERC20ABI)) 11032 if err != nil { 11033 return common.Address{}, nil, nil, err 11034 } 11035 11036 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SafeERC20Bin), backend) 11037 if err != nil { 11038 return common.Address{}, nil, nil, err 11039 } 11040 return address, tx, &SafeERC20{SafeERC20Caller: SafeERC20Caller{contract: contract}, SafeERC20Transactor: SafeERC20Transactor{contract: contract}, SafeERC20Filterer: SafeERC20Filterer{contract: contract}}, nil 11041 } 11042 11043 // SafeERC20 is an auto generated Go binding around an Ethereum contract. 11044 type SafeERC20 struct { 11045 SafeERC20Caller // Read-only binding to the contract 11046 SafeERC20Transactor // Write-only binding to the contract 11047 SafeERC20Filterer // Log filterer for contract events 11048 } 11049 11050 // SafeERC20Caller is an auto generated read-only Go binding around an Ethereum contract. 11051 type SafeERC20Caller struct { 11052 contract *bind.BoundContract // Generic contract wrapper for the low level calls 11053 } 11054 11055 // SafeERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. 11056 type SafeERC20Transactor struct { 11057 contract *bind.BoundContract // Generic contract wrapper for the low level calls 11058 } 11059 11060 // SafeERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. 11061 type SafeERC20Filterer struct { 11062 contract *bind.BoundContract // Generic contract wrapper for the low level calls 11063 } 11064 11065 // SafeERC20Session is an auto generated Go binding around an Ethereum contract, 11066 // with pre-set call and transact options. 11067 type SafeERC20Session struct { 11068 Contract *SafeERC20 // Generic contract binding to set the session for 11069 CallOpts bind.CallOpts // Call options to use throughout this session 11070 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 11071 } 11072 11073 // SafeERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, 11074 // with pre-set call options. 11075 type SafeERC20CallerSession struct { 11076 Contract *SafeERC20Caller // Generic contract caller binding to set the session for 11077 CallOpts bind.CallOpts // Call options to use throughout this session 11078 } 11079 11080 // SafeERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, 11081 // with pre-set transact options. 11082 type SafeERC20TransactorSession struct { 11083 Contract *SafeERC20Transactor // Generic contract transactor binding to set the session for 11084 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 11085 } 11086 11087 // SafeERC20Raw is an auto generated low-level Go binding around an Ethereum contract. 11088 type SafeERC20Raw struct { 11089 Contract *SafeERC20 // Generic contract binding to access the raw methods on 11090 } 11091 11092 // SafeERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 11093 type SafeERC20CallerRaw struct { 11094 Contract *SafeERC20Caller // Generic read-only contract binding to access the raw methods on 11095 } 11096 11097 // SafeERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 11098 type SafeERC20TransactorRaw struct { 11099 Contract *SafeERC20Transactor // Generic write-only contract binding to access the raw methods on 11100 } 11101 11102 // NewSafeERC20 creates a new instance of SafeERC20, bound to a specific deployed contract. 11103 func NewSafeERC20(address common.Address, backend bind.ContractBackend) (*SafeERC20, error) { 11104 contract, err := bindSafeERC20(address, backend, backend, backend) 11105 if err != nil { 11106 return nil, err 11107 } 11108 return &SafeERC20{SafeERC20Caller: SafeERC20Caller{contract: contract}, SafeERC20Transactor: SafeERC20Transactor{contract: contract}, SafeERC20Filterer: SafeERC20Filterer{contract: contract}}, nil 11109 } 11110 11111 // NewSafeERC20Caller creates a new read-only instance of SafeERC20, bound to a specific deployed contract. 11112 func NewSafeERC20Caller(address common.Address, caller bind.ContractCaller) (*SafeERC20Caller, error) { 11113 contract, err := bindSafeERC20(address, caller, nil, nil) 11114 if err != nil { 11115 return nil, err 11116 } 11117 return &SafeERC20Caller{contract: contract}, nil 11118 } 11119 11120 // NewSafeERC20Transactor creates a new write-only instance of SafeERC20, bound to a specific deployed contract. 11121 func NewSafeERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*SafeERC20Transactor, error) { 11122 contract, err := bindSafeERC20(address, nil, transactor, nil) 11123 if err != nil { 11124 return nil, err 11125 } 11126 return &SafeERC20Transactor{contract: contract}, nil 11127 } 11128 11129 // NewSafeERC20Filterer creates a new log filterer instance of SafeERC20, bound to a specific deployed contract. 11130 func NewSafeERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*SafeERC20Filterer, error) { 11131 contract, err := bindSafeERC20(address, nil, nil, filterer) 11132 if err != nil { 11133 return nil, err 11134 } 11135 return &SafeERC20Filterer{contract: contract}, nil 11136 } 11137 11138 // bindSafeERC20 binds a generic wrapper to an already deployed contract. 11139 func bindSafeERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 11140 parsed, err := abi.JSON(strings.NewReader(SafeERC20ABI)) 11141 if err != nil { 11142 return nil, err 11143 } 11144 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 11145 } 11146 11147 // Call invokes the (constant) contract method with params as input values and 11148 // sets the output to result. The result type might be a single field for simple 11149 // returns, a slice of interfaces for anonymous returns and a struct for named 11150 // returns. 11151 func (_SafeERC20 *SafeERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 11152 return _SafeERC20.Contract.SafeERC20Caller.contract.Call(opts, result, method, params...) 11153 } 11154 11155 // Transfer initiates a plain transaction to move funds to the contract, calling 11156 // its default method if one is available. 11157 func (_SafeERC20 *SafeERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 11158 return _SafeERC20.Contract.SafeERC20Transactor.contract.Transfer(opts) 11159 } 11160 11161 // Transact invokes the (paid) contract method with params as input values. 11162 func (_SafeERC20 *SafeERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 11163 return _SafeERC20.Contract.SafeERC20Transactor.contract.Transact(opts, method, params...) 11164 } 11165 11166 // Call invokes the (constant) contract method with params as input values and 11167 // sets the output to result. The result type might be a single field for simple 11168 // returns, a slice of interfaces for anonymous returns and a struct for named 11169 // returns. 11170 func (_SafeERC20 *SafeERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 11171 return _SafeERC20.Contract.contract.Call(opts, result, method, params...) 11172 } 11173 11174 // Transfer initiates a plain transaction to move funds to the contract, calling 11175 // its default method if one is available. 11176 func (_SafeERC20 *SafeERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 11177 return _SafeERC20.Contract.contract.Transfer(opts) 11178 } 11179 11180 // Transact invokes the (paid) contract method with params as input values. 11181 func (_SafeERC20 *SafeERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 11182 return _SafeERC20.Contract.contract.Transact(opts, method, params...) 11183 } 11184 11185 // SafeMathABI is the input ABI used to generate the binding from. 11186 const SafeMathABI = "[]" 11187 11188 // SafeMathBin is the compiled bytecode used for deploying new contracts. 11189 var SafeMathBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582045f810ccb41cd151344ccf006ddfbe7c3c58a867d26e345c6576ae09178171dc64736f6c634300050c0032" 11190 11191 // DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it. 11192 func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error) { 11193 parsed, err := abi.JSON(strings.NewReader(SafeMathABI)) 11194 if err != nil { 11195 return common.Address{}, nil, nil, err 11196 } 11197 11198 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SafeMathBin), backend) 11199 if err != nil { 11200 return common.Address{}, nil, nil, err 11201 } 11202 return address, tx, &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil 11203 } 11204 11205 // SafeMath is an auto generated Go binding around an Ethereum contract. 11206 type SafeMath struct { 11207 SafeMathCaller // Read-only binding to the contract 11208 SafeMathTransactor // Write-only binding to the contract 11209 SafeMathFilterer // Log filterer for contract events 11210 } 11211 11212 // SafeMathCaller is an auto generated read-only Go binding around an Ethereum contract. 11213 type SafeMathCaller struct { 11214 contract *bind.BoundContract // Generic contract wrapper for the low level calls 11215 } 11216 11217 // SafeMathTransactor is an auto generated write-only Go binding around an Ethereum contract. 11218 type SafeMathTransactor struct { 11219 contract *bind.BoundContract // Generic contract wrapper for the low level calls 11220 } 11221 11222 // SafeMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 11223 type SafeMathFilterer struct { 11224 contract *bind.BoundContract // Generic contract wrapper for the low level calls 11225 } 11226 11227 // SafeMathSession is an auto generated Go binding around an Ethereum contract, 11228 // with pre-set call and transact options. 11229 type SafeMathSession struct { 11230 Contract *SafeMath // Generic contract binding to set the session for 11231 CallOpts bind.CallOpts // Call options to use throughout this session 11232 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 11233 } 11234 11235 // SafeMathCallerSession is an auto generated read-only Go binding around an Ethereum contract, 11236 // with pre-set call options. 11237 type SafeMathCallerSession struct { 11238 Contract *SafeMathCaller // Generic contract caller binding to set the session for 11239 CallOpts bind.CallOpts // Call options to use throughout this session 11240 } 11241 11242 // SafeMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 11243 // with pre-set transact options. 11244 type SafeMathTransactorSession struct { 11245 Contract *SafeMathTransactor // Generic contract transactor binding to set the session for 11246 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 11247 } 11248 11249 // SafeMathRaw is an auto generated low-level Go binding around an Ethereum contract. 11250 type SafeMathRaw struct { 11251 Contract *SafeMath // Generic contract binding to access the raw methods on 11252 } 11253 11254 // SafeMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 11255 type SafeMathCallerRaw struct { 11256 Contract *SafeMathCaller // Generic read-only contract binding to access the raw methods on 11257 } 11258 11259 // SafeMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 11260 type SafeMathTransactorRaw struct { 11261 Contract *SafeMathTransactor // Generic write-only contract binding to access the raw methods on 11262 } 11263 11264 // NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract. 11265 func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error) { 11266 contract, err := bindSafeMath(address, backend, backend, backend) 11267 if err != nil { 11268 return nil, err 11269 } 11270 return &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil 11271 } 11272 11273 // NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract. 11274 func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error) { 11275 contract, err := bindSafeMath(address, caller, nil, nil) 11276 if err != nil { 11277 return nil, err 11278 } 11279 return &SafeMathCaller{contract: contract}, nil 11280 } 11281 11282 // NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract. 11283 func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error) { 11284 contract, err := bindSafeMath(address, nil, transactor, nil) 11285 if err != nil { 11286 return nil, err 11287 } 11288 return &SafeMathTransactor{contract: contract}, nil 11289 } 11290 11291 // NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract. 11292 func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error) { 11293 contract, err := bindSafeMath(address, nil, nil, filterer) 11294 if err != nil { 11295 return nil, err 11296 } 11297 return &SafeMathFilterer{contract: contract}, nil 11298 } 11299 11300 // bindSafeMath binds a generic wrapper to an already deployed contract. 11301 func bindSafeMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 11302 parsed, err := abi.JSON(strings.NewReader(SafeMathABI)) 11303 if err != nil { 11304 return nil, err 11305 } 11306 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 11307 } 11308 11309 // Call invokes the (constant) contract method with params as input values and 11310 // sets the output to result. The result type might be a single field for simple 11311 // returns, a slice of interfaces for anonymous returns and a struct for named 11312 // returns. 11313 func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 11314 return _SafeMath.Contract.SafeMathCaller.contract.Call(opts, result, method, params...) 11315 } 11316 11317 // Transfer initiates a plain transaction to move funds to the contract, calling 11318 // its default method if one is available. 11319 func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 11320 return _SafeMath.Contract.SafeMathTransactor.contract.Transfer(opts) 11321 } 11322 11323 // Transact invokes the (paid) contract method with params as input values. 11324 func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 11325 return _SafeMath.Contract.SafeMathTransactor.contract.Transact(opts, method, params...) 11326 } 11327 11328 // Call invokes the (constant) contract method with params as input values and 11329 // sets the output to result. The result type might be a single field for simple 11330 // returns, a slice of interfaces for anonymous returns and a struct for named 11331 // returns. 11332 func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 11333 return _SafeMath.Contract.contract.Call(opts, result, method, params...) 11334 } 11335 11336 // Transfer initiates a plain transaction to move funds to the contract, calling 11337 // its default method if one is available. 11338 func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 11339 return _SafeMath.Contract.contract.Transfer(opts) 11340 } 11341 11342 // Transact invokes the (paid) contract method with params as input values. 11343 func (_SafeMath *SafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 11344 return _SafeMath.Contract.contract.Transact(opts, method, params...) 11345 } 11346 11347 // SeigManagerIABI is the input ABI used to generate the binding from. 11348 const SeigManagerIABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"DEFAULT_FACTOR\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"additionalTotBurnAmount\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"totAmount\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"coinages\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"commissionRates\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"deployCoinage\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"depositManager\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"}],\"name\":\"lastCommitBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"lastSeigBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"onCommit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onDeposit\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onTransfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"onWithdraw\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"pausedBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"powerton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"registry\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigPerBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"commission\",\"type\":\"uint256\"},{\"internalType\":\"bool\",\"name\":\"isCommissionRateNegative\",\"type\":\"bool\"}],\"name\":\"setCommissionRate\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"stakeOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"ton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"tot\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"rootchain\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"uncomittedStakeOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"unpausedBlock\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"wton\",\"outputs\":[{\"internalType\":\"address\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]" 11349 11350 // SeigManagerIFuncSigs maps the 4-byte function signature to its string representation. 11351 var SeigManagerIFuncSigs = map[string]string{ 11352 "8bf91dc4": "DEFAULT_FACTOR()", 11353 "48c8577e": "additionalTotBurnAmount(address,address,uint256)", 11354 "4c063c19": "coinages(address)", 11355 "7b056c1b": "commissionRates(address)", 11356 "833a774f": "deployCoinage(address)", 11357 "6c7ac9d8": "depositManager()", 11358 "c59f1046": "lastCommitBlock(address)", 11359 "f35c89e8": "lastSeigBlock()", 11360 "359c4d59": "onCommit()", 11361 "412c6d50": "onDeposit(address,address,uint256)", 11362 "4a393149": "onTransfer(address,address,uint256)", 11363 "f850ffaa": "onWithdraw(address,address,uint256)", 11364 "32053c99": "pausedBlock()", 11365 "3e832e1d": "powerton()", 11366 "7b103999": "registry()", 11367 "5f40a349": "seigPerBlock()", 11368 "4224ed66": "setCommissionRate(address,uint256,bool)", 11369 "ce4cb876": "stakeOf(address,address)", 11370 "cc48b947": "ton()", 11371 "a16d6aa7": "tot()", 11372 "fa9789c8": "uncomittedStakeOf(address,address)", 11373 "1cc47890": "unpausedBlock()", 11374 "8d62d949": "wton()", 11375 } 11376 11377 // SeigManagerI is an auto generated Go binding around an Ethereum contract. 11378 type SeigManagerI struct { 11379 SeigManagerICaller // Read-only binding to the contract 11380 SeigManagerITransactor // Write-only binding to the contract 11381 SeigManagerIFilterer // Log filterer for contract events 11382 } 11383 11384 // SeigManagerICaller is an auto generated read-only Go binding around an Ethereum contract. 11385 type SeigManagerICaller struct { 11386 contract *bind.BoundContract // Generic contract wrapper for the low level calls 11387 } 11388 11389 // SeigManagerITransactor is an auto generated write-only Go binding around an Ethereum contract. 11390 type SeigManagerITransactor struct { 11391 contract *bind.BoundContract // Generic contract wrapper for the low level calls 11392 } 11393 11394 // SeigManagerIFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 11395 type SeigManagerIFilterer struct { 11396 contract *bind.BoundContract // Generic contract wrapper for the low level calls 11397 } 11398 11399 // SeigManagerISession is an auto generated Go binding around an Ethereum contract, 11400 // with pre-set call and transact options. 11401 type SeigManagerISession struct { 11402 Contract *SeigManagerI // Generic contract binding to set the session for 11403 CallOpts bind.CallOpts // Call options to use throughout this session 11404 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 11405 } 11406 11407 // SeigManagerICallerSession is an auto generated read-only Go binding around an Ethereum contract, 11408 // with pre-set call options. 11409 type SeigManagerICallerSession struct { 11410 Contract *SeigManagerICaller // Generic contract caller binding to set the session for 11411 CallOpts bind.CallOpts // Call options to use throughout this session 11412 } 11413 11414 // SeigManagerITransactorSession is an auto generated write-only Go binding around an Ethereum contract, 11415 // with pre-set transact options. 11416 type SeigManagerITransactorSession struct { 11417 Contract *SeigManagerITransactor // Generic contract transactor binding to set the session for 11418 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 11419 } 11420 11421 // SeigManagerIRaw is an auto generated low-level Go binding around an Ethereum contract. 11422 type SeigManagerIRaw struct { 11423 Contract *SeigManagerI // Generic contract binding to access the raw methods on 11424 } 11425 11426 // SeigManagerICallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 11427 type SeigManagerICallerRaw struct { 11428 Contract *SeigManagerICaller // Generic read-only contract binding to access the raw methods on 11429 } 11430 11431 // SeigManagerITransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 11432 type SeigManagerITransactorRaw struct { 11433 Contract *SeigManagerITransactor // Generic write-only contract binding to access the raw methods on 11434 } 11435 11436 // NewSeigManagerI creates a new instance of SeigManagerI, bound to a specific deployed contract. 11437 func NewSeigManagerI(address common.Address, backend bind.ContractBackend) (*SeigManagerI, error) { 11438 contract, err := bindSeigManagerI(address, backend, backend, backend) 11439 if err != nil { 11440 return nil, err 11441 } 11442 return &SeigManagerI{SeigManagerICaller: SeigManagerICaller{contract: contract}, SeigManagerITransactor: SeigManagerITransactor{contract: contract}, SeigManagerIFilterer: SeigManagerIFilterer{contract: contract}}, nil 11443 } 11444 11445 // NewSeigManagerICaller creates a new read-only instance of SeigManagerI, bound to a specific deployed contract. 11446 func NewSeigManagerICaller(address common.Address, caller bind.ContractCaller) (*SeigManagerICaller, error) { 11447 contract, err := bindSeigManagerI(address, caller, nil, nil) 11448 if err != nil { 11449 return nil, err 11450 } 11451 return &SeigManagerICaller{contract: contract}, nil 11452 } 11453 11454 // NewSeigManagerITransactor creates a new write-only instance of SeigManagerI, bound to a specific deployed contract. 11455 func NewSeigManagerITransactor(address common.Address, transactor bind.ContractTransactor) (*SeigManagerITransactor, error) { 11456 contract, err := bindSeigManagerI(address, nil, transactor, nil) 11457 if err != nil { 11458 return nil, err 11459 } 11460 return &SeigManagerITransactor{contract: contract}, nil 11461 } 11462 11463 // NewSeigManagerIFilterer creates a new log filterer instance of SeigManagerI, bound to a specific deployed contract. 11464 func NewSeigManagerIFilterer(address common.Address, filterer bind.ContractFilterer) (*SeigManagerIFilterer, error) { 11465 contract, err := bindSeigManagerI(address, nil, nil, filterer) 11466 if err != nil { 11467 return nil, err 11468 } 11469 return &SeigManagerIFilterer{contract: contract}, nil 11470 } 11471 11472 // bindSeigManagerI binds a generic wrapper to an already deployed contract. 11473 func bindSeigManagerI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 11474 parsed, err := abi.JSON(strings.NewReader(SeigManagerIABI)) 11475 if err != nil { 11476 return nil, err 11477 } 11478 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 11479 } 11480 11481 // Call invokes the (constant) contract method with params as input values and 11482 // sets the output to result. The result type might be a single field for simple 11483 // returns, a slice of interfaces for anonymous returns and a struct for named 11484 // returns. 11485 func (_SeigManagerI *SeigManagerIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 11486 return _SeigManagerI.Contract.SeigManagerICaller.contract.Call(opts, result, method, params...) 11487 } 11488 11489 // Transfer initiates a plain transaction to move funds to the contract, calling 11490 // its default method if one is available. 11491 func (_SeigManagerI *SeigManagerIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 11492 return _SeigManagerI.Contract.SeigManagerITransactor.contract.Transfer(opts) 11493 } 11494 11495 // Transact invokes the (paid) contract method with params as input values. 11496 func (_SeigManagerI *SeigManagerIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 11497 return _SeigManagerI.Contract.SeigManagerITransactor.contract.Transact(opts, method, params...) 11498 } 11499 11500 // Call invokes the (constant) contract method with params as input values and 11501 // sets the output to result. The result type might be a single field for simple 11502 // returns, a slice of interfaces for anonymous returns and a struct for named 11503 // returns. 11504 func (_SeigManagerI *SeigManagerICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 11505 return _SeigManagerI.Contract.contract.Call(opts, result, method, params...) 11506 } 11507 11508 // Transfer initiates a plain transaction to move funds to the contract, calling 11509 // its default method if one is available. 11510 func (_SeigManagerI *SeigManagerITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 11511 return _SeigManagerI.Contract.contract.Transfer(opts) 11512 } 11513 11514 // Transact invokes the (paid) contract method with params as input values. 11515 func (_SeigManagerI *SeigManagerITransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 11516 return _SeigManagerI.Contract.contract.Transact(opts, method, params...) 11517 } 11518 11519 // DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4. 11520 // 11521 // Solidity: function DEFAULT_FACTOR() constant returns(uint256) 11522 func (_SeigManagerI *SeigManagerICaller) DEFAULTFACTOR(opts *bind.CallOpts) (*big.Int, error) { 11523 var ( 11524 ret0 = new(*big.Int) 11525 ) 11526 out := ret0 11527 err := _SeigManagerI.contract.Call(opts, out, "DEFAULT_FACTOR") 11528 return *ret0, err 11529 } 11530 11531 // DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4. 11532 // 11533 // Solidity: function DEFAULT_FACTOR() constant returns(uint256) 11534 func (_SeigManagerI *SeigManagerISession) DEFAULTFACTOR() (*big.Int, error) { 11535 return _SeigManagerI.Contract.DEFAULTFACTOR(&_SeigManagerI.CallOpts) 11536 } 11537 11538 // DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4. 11539 // 11540 // Solidity: function DEFAULT_FACTOR() constant returns(uint256) 11541 func (_SeigManagerI *SeigManagerICallerSession) DEFAULTFACTOR() (*big.Int, error) { 11542 return _SeigManagerI.Contract.DEFAULTFACTOR(&_SeigManagerI.CallOpts) 11543 } 11544 11545 // AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e. 11546 // 11547 // Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount) 11548 func (_SeigManagerI *SeigManagerICaller) AdditionalTotBurnAmount(opts *bind.CallOpts, rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) { 11549 var ( 11550 ret0 = new(*big.Int) 11551 ) 11552 out := ret0 11553 err := _SeigManagerI.contract.Call(opts, out, "additionalTotBurnAmount", rootchain, account, amount) 11554 return *ret0, err 11555 } 11556 11557 // AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e. 11558 // 11559 // Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount) 11560 func (_SeigManagerI *SeigManagerISession) AdditionalTotBurnAmount(rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) { 11561 return _SeigManagerI.Contract.AdditionalTotBurnAmount(&_SeigManagerI.CallOpts, rootchain, account, amount) 11562 } 11563 11564 // AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e. 11565 // 11566 // Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount) 11567 func (_SeigManagerI *SeigManagerICallerSession) AdditionalTotBurnAmount(rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) { 11568 return _SeigManagerI.Contract.AdditionalTotBurnAmount(&_SeigManagerI.CallOpts, rootchain, account, amount) 11569 } 11570 11571 // Coinages is a free data retrieval call binding the contract method 0x4c063c19. 11572 // 11573 // Solidity: function coinages(address rootchain) constant returns(address) 11574 func (_SeigManagerI *SeigManagerICaller) Coinages(opts *bind.CallOpts, rootchain common.Address) (common.Address, error) { 11575 var ( 11576 ret0 = new(common.Address) 11577 ) 11578 out := ret0 11579 err := _SeigManagerI.contract.Call(opts, out, "coinages", rootchain) 11580 return *ret0, err 11581 } 11582 11583 // Coinages is a free data retrieval call binding the contract method 0x4c063c19. 11584 // 11585 // Solidity: function coinages(address rootchain) constant returns(address) 11586 func (_SeigManagerI *SeigManagerISession) Coinages(rootchain common.Address) (common.Address, error) { 11587 return _SeigManagerI.Contract.Coinages(&_SeigManagerI.CallOpts, rootchain) 11588 } 11589 11590 // Coinages is a free data retrieval call binding the contract method 0x4c063c19. 11591 // 11592 // Solidity: function coinages(address rootchain) constant returns(address) 11593 func (_SeigManagerI *SeigManagerICallerSession) Coinages(rootchain common.Address) (common.Address, error) { 11594 return _SeigManagerI.Contract.Coinages(&_SeigManagerI.CallOpts, rootchain) 11595 } 11596 11597 // CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b. 11598 // 11599 // Solidity: function commissionRates(address rootchain) constant returns(uint256) 11600 func (_SeigManagerI *SeigManagerICaller) CommissionRates(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) { 11601 var ( 11602 ret0 = new(*big.Int) 11603 ) 11604 out := ret0 11605 err := _SeigManagerI.contract.Call(opts, out, "commissionRates", rootchain) 11606 return *ret0, err 11607 } 11608 11609 // CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b. 11610 // 11611 // Solidity: function commissionRates(address rootchain) constant returns(uint256) 11612 func (_SeigManagerI *SeigManagerISession) CommissionRates(rootchain common.Address) (*big.Int, error) { 11613 return _SeigManagerI.Contract.CommissionRates(&_SeigManagerI.CallOpts, rootchain) 11614 } 11615 11616 // CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b. 11617 // 11618 // Solidity: function commissionRates(address rootchain) constant returns(uint256) 11619 func (_SeigManagerI *SeigManagerICallerSession) CommissionRates(rootchain common.Address) (*big.Int, error) { 11620 return _SeigManagerI.Contract.CommissionRates(&_SeigManagerI.CallOpts, rootchain) 11621 } 11622 11623 // DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8. 11624 // 11625 // Solidity: function depositManager() constant returns(address) 11626 func (_SeigManagerI *SeigManagerICaller) DepositManager(opts *bind.CallOpts) (common.Address, error) { 11627 var ( 11628 ret0 = new(common.Address) 11629 ) 11630 out := ret0 11631 err := _SeigManagerI.contract.Call(opts, out, "depositManager") 11632 return *ret0, err 11633 } 11634 11635 // DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8. 11636 // 11637 // Solidity: function depositManager() constant returns(address) 11638 func (_SeigManagerI *SeigManagerISession) DepositManager() (common.Address, error) { 11639 return _SeigManagerI.Contract.DepositManager(&_SeigManagerI.CallOpts) 11640 } 11641 11642 // DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8. 11643 // 11644 // Solidity: function depositManager() constant returns(address) 11645 func (_SeigManagerI *SeigManagerICallerSession) DepositManager() (common.Address, error) { 11646 return _SeigManagerI.Contract.DepositManager(&_SeigManagerI.CallOpts) 11647 } 11648 11649 // LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046. 11650 // 11651 // Solidity: function lastCommitBlock(address rootchain) constant returns(uint256) 11652 func (_SeigManagerI *SeigManagerICaller) LastCommitBlock(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) { 11653 var ( 11654 ret0 = new(*big.Int) 11655 ) 11656 out := ret0 11657 err := _SeigManagerI.contract.Call(opts, out, "lastCommitBlock", rootchain) 11658 return *ret0, err 11659 } 11660 11661 // LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046. 11662 // 11663 // Solidity: function lastCommitBlock(address rootchain) constant returns(uint256) 11664 func (_SeigManagerI *SeigManagerISession) LastCommitBlock(rootchain common.Address) (*big.Int, error) { 11665 return _SeigManagerI.Contract.LastCommitBlock(&_SeigManagerI.CallOpts, rootchain) 11666 } 11667 11668 // LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046. 11669 // 11670 // Solidity: function lastCommitBlock(address rootchain) constant returns(uint256) 11671 func (_SeigManagerI *SeigManagerICallerSession) LastCommitBlock(rootchain common.Address) (*big.Int, error) { 11672 return _SeigManagerI.Contract.LastCommitBlock(&_SeigManagerI.CallOpts, rootchain) 11673 } 11674 11675 // LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8. 11676 // 11677 // Solidity: function lastSeigBlock() constant returns(uint256) 11678 func (_SeigManagerI *SeigManagerICaller) LastSeigBlock(opts *bind.CallOpts) (*big.Int, error) { 11679 var ( 11680 ret0 = new(*big.Int) 11681 ) 11682 out := ret0 11683 err := _SeigManagerI.contract.Call(opts, out, "lastSeigBlock") 11684 return *ret0, err 11685 } 11686 11687 // LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8. 11688 // 11689 // Solidity: function lastSeigBlock() constant returns(uint256) 11690 func (_SeigManagerI *SeigManagerISession) LastSeigBlock() (*big.Int, error) { 11691 return _SeigManagerI.Contract.LastSeigBlock(&_SeigManagerI.CallOpts) 11692 } 11693 11694 // LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8. 11695 // 11696 // Solidity: function lastSeigBlock() constant returns(uint256) 11697 func (_SeigManagerI *SeigManagerICallerSession) LastSeigBlock() (*big.Int, error) { 11698 return _SeigManagerI.Contract.LastSeigBlock(&_SeigManagerI.CallOpts) 11699 } 11700 11701 // PausedBlock is a free data retrieval call binding the contract method 0x32053c99. 11702 // 11703 // Solidity: function pausedBlock() constant returns(uint256) 11704 func (_SeigManagerI *SeigManagerICaller) PausedBlock(opts *bind.CallOpts) (*big.Int, error) { 11705 var ( 11706 ret0 = new(*big.Int) 11707 ) 11708 out := ret0 11709 err := _SeigManagerI.contract.Call(opts, out, "pausedBlock") 11710 return *ret0, err 11711 } 11712 11713 // PausedBlock is a free data retrieval call binding the contract method 0x32053c99. 11714 // 11715 // Solidity: function pausedBlock() constant returns(uint256) 11716 func (_SeigManagerI *SeigManagerISession) PausedBlock() (*big.Int, error) { 11717 return _SeigManagerI.Contract.PausedBlock(&_SeigManagerI.CallOpts) 11718 } 11719 11720 // PausedBlock is a free data retrieval call binding the contract method 0x32053c99. 11721 // 11722 // Solidity: function pausedBlock() constant returns(uint256) 11723 func (_SeigManagerI *SeigManagerICallerSession) PausedBlock() (*big.Int, error) { 11724 return _SeigManagerI.Contract.PausedBlock(&_SeigManagerI.CallOpts) 11725 } 11726 11727 // Powerton is a free data retrieval call binding the contract method 0x3e832e1d. 11728 // 11729 // Solidity: function powerton() constant returns(address) 11730 func (_SeigManagerI *SeigManagerICaller) Powerton(opts *bind.CallOpts) (common.Address, error) { 11731 var ( 11732 ret0 = new(common.Address) 11733 ) 11734 out := ret0 11735 err := _SeigManagerI.contract.Call(opts, out, "powerton") 11736 return *ret0, err 11737 } 11738 11739 // Powerton is a free data retrieval call binding the contract method 0x3e832e1d. 11740 // 11741 // Solidity: function powerton() constant returns(address) 11742 func (_SeigManagerI *SeigManagerISession) Powerton() (common.Address, error) { 11743 return _SeigManagerI.Contract.Powerton(&_SeigManagerI.CallOpts) 11744 } 11745 11746 // Powerton is a free data retrieval call binding the contract method 0x3e832e1d. 11747 // 11748 // Solidity: function powerton() constant returns(address) 11749 func (_SeigManagerI *SeigManagerICallerSession) Powerton() (common.Address, error) { 11750 return _SeigManagerI.Contract.Powerton(&_SeigManagerI.CallOpts) 11751 } 11752 11753 // Registry is a free data retrieval call binding the contract method 0x7b103999. 11754 // 11755 // Solidity: function registry() constant returns(address) 11756 func (_SeigManagerI *SeigManagerICaller) Registry(opts *bind.CallOpts) (common.Address, error) { 11757 var ( 11758 ret0 = new(common.Address) 11759 ) 11760 out := ret0 11761 err := _SeigManagerI.contract.Call(opts, out, "registry") 11762 return *ret0, err 11763 } 11764 11765 // Registry is a free data retrieval call binding the contract method 0x7b103999. 11766 // 11767 // Solidity: function registry() constant returns(address) 11768 func (_SeigManagerI *SeigManagerISession) Registry() (common.Address, error) { 11769 return _SeigManagerI.Contract.Registry(&_SeigManagerI.CallOpts) 11770 } 11771 11772 // Registry is a free data retrieval call binding the contract method 0x7b103999. 11773 // 11774 // Solidity: function registry() constant returns(address) 11775 func (_SeigManagerI *SeigManagerICallerSession) Registry() (common.Address, error) { 11776 return _SeigManagerI.Contract.Registry(&_SeigManagerI.CallOpts) 11777 } 11778 11779 // SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349. 11780 // 11781 // Solidity: function seigPerBlock() constant returns(uint256) 11782 func (_SeigManagerI *SeigManagerICaller) SeigPerBlock(opts *bind.CallOpts) (*big.Int, error) { 11783 var ( 11784 ret0 = new(*big.Int) 11785 ) 11786 out := ret0 11787 err := _SeigManagerI.contract.Call(opts, out, "seigPerBlock") 11788 return *ret0, err 11789 } 11790 11791 // SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349. 11792 // 11793 // Solidity: function seigPerBlock() constant returns(uint256) 11794 func (_SeigManagerI *SeigManagerISession) SeigPerBlock() (*big.Int, error) { 11795 return _SeigManagerI.Contract.SeigPerBlock(&_SeigManagerI.CallOpts) 11796 } 11797 11798 // SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349. 11799 // 11800 // Solidity: function seigPerBlock() constant returns(uint256) 11801 func (_SeigManagerI *SeigManagerICallerSession) SeigPerBlock() (*big.Int, error) { 11802 return _SeigManagerI.Contract.SeigPerBlock(&_SeigManagerI.CallOpts) 11803 } 11804 11805 // StakeOf is a free data retrieval call binding the contract method 0xce4cb876. 11806 // 11807 // Solidity: function stakeOf(address rootchain, address account) constant returns(uint256) 11808 func (_SeigManagerI *SeigManagerICaller) StakeOf(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 11809 var ( 11810 ret0 = new(*big.Int) 11811 ) 11812 out := ret0 11813 err := _SeigManagerI.contract.Call(opts, out, "stakeOf", rootchain, account) 11814 return *ret0, err 11815 } 11816 11817 // StakeOf is a free data retrieval call binding the contract method 0xce4cb876. 11818 // 11819 // Solidity: function stakeOf(address rootchain, address account) constant returns(uint256) 11820 func (_SeigManagerI *SeigManagerISession) StakeOf(rootchain common.Address, account common.Address) (*big.Int, error) { 11821 return _SeigManagerI.Contract.StakeOf(&_SeigManagerI.CallOpts, rootchain, account) 11822 } 11823 11824 // StakeOf is a free data retrieval call binding the contract method 0xce4cb876. 11825 // 11826 // Solidity: function stakeOf(address rootchain, address account) constant returns(uint256) 11827 func (_SeigManagerI *SeigManagerICallerSession) StakeOf(rootchain common.Address, account common.Address) (*big.Int, error) { 11828 return _SeigManagerI.Contract.StakeOf(&_SeigManagerI.CallOpts, rootchain, account) 11829 } 11830 11831 // Ton is a free data retrieval call binding the contract method 0xcc48b947. 11832 // 11833 // Solidity: function ton() constant returns(address) 11834 func (_SeigManagerI *SeigManagerICaller) Ton(opts *bind.CallOpts) (common.Address, error) { 11835 var ( 11836 ret0 = new(common.Address) 11837 ) 11838 out := ret0 11839 err := _SeigManagerI.contract.Call(opts, out, "ton") 11840 return *ret0, err 11841 } 11842 11843 // Ton is a free data retrieval call binding the contract method 0xcc48b947. 11844 // 11845 // Solidity: function ton() constant returns(address) 11846 func (_SeigManagerI *SeigManagerISession) Ton() (common.Address, error) { 11847 return _SeigManagerI.Contract.Ton(&_SeigManagerI.CallOpts) 11848 } 11849 11850 // Ton is a free data retrieval call binding the contract method 0xcc48b947. 11851 // 11852 // Solidity: function ton() constant returns(address) 11853 func (_SeigManagerI *SeigManagerICallerSession) Ton() (common.Address, error) { 11854 return _SeigManagerI.Contract.Ton(&_SeigManagerI.CallOpts) 11855 } 11856 11857 // Tot is a free data retrieval call binding the contract method 0xa16d6aa7. 11858 // 11859 // Solidity: function tot() constant returns(address) 11860 func (_SeigManagerI *SeigManagerICaller) Tot(opts *bind.CallOpts) (common.Address, error) { 11861 var ( 11862 ret0 = new(common.Address) 11863 ) 11864 out := ret0 11865 err := _SeigManagerI.contract.Call(opts, out, "tot") 11866 return *ret0, err 11867 } 11868 11869 // Tot is a free data retrieval call binding the contract method 0xa16d6aa7. 11870 // 11871 // Solidity: function tot() constant returns(address) 11872 func (_SeigManagerI *SeigManagerISession) Tot() (common.Address, error) { 11873 return _SeigManagerI.Contract.Tot(&_SeigManagerI.CallOpts) 11874 } 11875 11876 // Tot is a free data retrieval call binding the contract method 0xa16d6aa7. 11877 // 11878 // Solidity: function tot() constant returns(address) 11879 func (_SeigManagerI *SeigManagerICallerSession) Tot() (common.Address, error) { 11880 return _SeigManagerI.Contract.Tot(&_SeigManagerI.CallOpts) 11881 } 11882 11883 // UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8. 11884 // 11885 // Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256) 11886 func (_SeigManagerI *SeigManagerICaller) UncomittedStakeOf(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 11887 var ( 11888 ret0 = new(*big.Int) 11889 ) 11890 out := ret0 11891 err := _SeigManagerI.contract.Call(opts, out, "uncomittedStakeOf", rootchain, account) 11892 return *ret0, err 11893 } 11894 11895 // UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8. 11896 // 11897 // Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256) 11898 func (_SeigManagerI *SeigManagerISession) UncomittedStakeOf(rootchain common.Address, account common.Address) (*big.Int, error) { 11899 return _SeigManagerI.Contract.UncomittedStakeOf(&_SeigManagerI.CallOpts, rootchain, account) 11900 } 11901 11902 // UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8. 11903 // 11904 // Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256) 11905 func (_SeigManagerI *SeigManagerICallerSession) UncomittedStakeOf(rootchain common.Address, account common.Address) (*big.Int, error) { 11906 return _SeigManagerI.Contract.UncomittedStakeOf(&_SeigManagerI.CallOpts, rootchain, account) 11907 } 11908 11909 // UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890. 11910 // 11911 // Solidity: function unpausedBlock() constant returns(uint256) 11912 func (_SeigManagerI *SeigManagerICaller) UnpausedBlock(opts *bind.CallOpts) (*big.Int, error) { 11913 var ( 11914 ret0 = new(*big.Int) 11915 ) 11916 out := ret0 11917 err := _SeigManagerI.contract.Call(opts, out, "unpausedBlock") 11918 return *ret0, err 11919 } 11920 11921 // UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890. 11922 // 11923 // Solidity: function unpausedBlock() constant returns(uint256) 11924 func (_SeigManagerI *SeigManagerISession) UnpausedBlock() (*big.Int, error) { 11925 return _SeigManagerI.Contract.UnpausedBlock(&_SeigManagerI.CallOpts) 11926 } 11927 11928 // UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890. 11929 // 11930 // Solidity: function unpausedBlock() constant returns(uint256) 11931 func (_SeigManagerI *SeigManagerICallerSession) UnpausedBlock() (*big.Int, error) { 11932 return _SeigManagerI.Contract.UnpausedBlock(&_SeigManagerI.CallOpts) 11933 } 11934 11935 // Wton is a free data retrieval call binding the contract method 0x8d62d949. 11936 // 11937 // Solidity: function wton() constant returns(address) 11938 func (_SeigManagerI *SeigManagerICaller) Wton(opts *bind.CallOpts) (common.Address, error) { 11939 var ( 11940 ret0 = new(common.Address) 11941 ) 11942 out := ret0 11943 err := _SeigManagerI.contract.Call(opts, out, "wton") 11944 return *ret0, err 11945 } 11946 11947 // Wton is a free data retrieval call binding the contract method 0x8d62d949. 11948 // 11949 // Solidity: function wton() constant returns(address) 11950 func (_SeigManagerI *SeigManagerISession) Wton() (common.Address, error) { 11951 return _SeigManagerI.Contract.Wton(&_SeigManagerI.CallOpts) 11952 } 11953 11954 // Wton is a free data retrieval call binding the contract method 0x8d62d949. 11955 // 11956 // Solidity: function wton() constant returns(address) 11957 func (_SeigManagerI *SeigManagerICallerSession) Wton() (common.Address, error) { 11958 return _SeigManagerI.Contract.Wton(&_SeigManagerI.CallOpts) 11959 } 11960 11961 // DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f. 11962 // 11963 // Solidity: function deployCoinage(address rootchain) returns(bool) 11964 func (_SeigManagerI *SeigManagerITransactor) DeployCoinage(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) { 11965 return _SeigManagerI.contract.Transact(opts, "deployCoinage", rootchain) 11966 } 11967 11968 // DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f. 11969 // 11970 // Solidity: function deployCoinage(address rootchain) returns(bool) 11971 func (_SeigManagerI *SeigManagerISession) DeployCoinage(rootchain common.Address) (*types.Transaction, error) { 11972 return _SeigManagerI.Contract.DeployCoinage(&_SeigManagerI.TransactOpts, rootchain) 11973 } 11974 11975 // DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f. 11976 // 11977 // Solidity: function deployCoinage(address rootchain) returns(bool) 11978 func (_SeigManagerI *SeigManagerITransactorSession) DeployCoinage(rootchain common.Address) (*types.Transaction, error) { 11979 return _SeigManagerI.Contract.DeployCoinage(&_SeigManagerI.TransactOpts, rootchain) 11980 } 11981 11982 // OnCommit is a paid mutator transaction binding the contract method 0x359c4d59. 11983 // 11984 // Solidity: function onCommit() returns(bool) 11985 func (_SeigManagerI *SeigManagerITransactor) OnCommit(opts *bind.TransactOpts) (*types.Transaction, error) { 11986 return _SeigManagerI.contract.Transact(opts, "onCommit") 11987 } 11988 11989 // OnCommit is a paid mutator transaction binding the contract method 0x359c4d59. 11990 // 11991 // Solidity: function onCommit() returns(bool) 11992 func (_SeigManagerI *SeigManagerISession) OnCommit() (*types.Transaction, error) { 11993 return _SeigManagerI.Contract.OnCommit(&_SeigManagerI.TransactOpts) 11994 } 11995 11996 // OnCommit is a paid mutator transaction binding the contract method 0x359c4d59. 11997 // 11998 // Solidity: function onCommit() returns(bool) 11999 func (_SeigManagerI *SeigManagerITransactorSession) OnCommit() (*types.Transaction, error) { 12000 return _SeigManagerI.Contract.OnCommit(&_SeigManagerI.TransactOpts) 12001 } 12002 12003 // OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50. 12004 // 12005 // Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool) 12006 func (_SeigManagerI *SeigManagerITransactor) OnDeposit(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) { 12007 return _SeigManagerI.contract.Transact(opts, "onDeposit", rootchain, account, amount) 12008 } 12009 12010 // OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50. 12011 // 12012 // Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool) 12013 func (_SeigManagerI *SeigManagerISession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) { 12014 return _SeigManagerI.Contract.OnDeposit(&_SeigManagerI.TransactOpts, rootchain, account, amount) 12015 } 12016 12017 // OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50. 12018 // 12019 // Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool) 12020 func (_SeigManagerI *SeigManagerITransactorSession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) { 12021 return _SeigManagerI.Contract.OnDeposit(&_SeigManagerI.TransactOpts, rootchain, account, amount) 12022 } 12023 12024 // OnTransfer is a paid mutator transaction binding the contract method 0x4a393149. 12025 // 12026 // Solidity: function onTransfer(address sender, address recipient, uint256 amount) returns(bool) 12027 func (_SeigManagerI *SeigManagerITransactor) OnTransfer(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 12028 return _SeigManagerI.contract.Transact(opts, "onTransfer", sender, recipient, amount) 12029 } 12030 12031 // OnTransfer is a paid mutator transaction binding the contract method 0x4a393149. 12032 // 12033 // Solidity: function onTransfer(address sender, address recipient, uint256 amount) returns(bool) 12034 func (_SeigManagerI *SeigManagerISession) OnTransfer(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 12035 return _SeigManagerI.Contract.OnTransfer(&_SeigManagerI.TransactOpts, sender, recipient, amount) 12036 } 12037 12038 // OnTransfer is a paid mutator transaction binding the contract method 0x4a393149. 12039 // 12040 // Solidity: function onTransfer(address sender, address recipient, uint256 amount) returns(bool) 12041 func (_SeigManagerI *SeigManagerITransactorSession) OnTransfer(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 12042 return _SeigManagerI.Contract.OnTransfer(&_SeigManagerI.TransactOpts, sender, recipient, amount) 12043 } 12044 12045 // OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa. 12046 // 12047 // Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool) 12048 func (_SeigManagerI *SeigManagerITransactor) OnWithdraw(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) { 12049 return _SeigManagerI.contract.Transact(opts, "onWithdraw", rootchain, account, amount) 12050 } 12051 12052 // OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa. 12053 // 12054 // Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool) 12055 func (_SeigManagerI *SeigManagerISession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) { 12056 return _SeigManagerI.Contract.OnWithdraw(&_SeigManagerI.TransactOpts, rootchain, account, amount) 12057 } 12058 12059 // OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa. 12060 // 12061 // Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool) 12062 func (_SeigManagerI *SeigManagerITransactorSession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) { 12063 return _SeigManagerI.Contract.OnWithdraw(&_SeigManagerI.TransactOpts, rootchain, account, amount) 12064 } 12065 12066 // SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66. 12067 // 12068 // Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool) 12069 func (_SeigManagerI *SeigManagerITransactor) SetCommissionRate(opts *bind.TransactOpts, rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) { 12070 return _SeigManagerI.contract.Transact(opts, "setCommissionRate", rootchain, commission, isCommissionRateNegative) 12071 } 12072 12073 // SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66. 12074 // 12075 // Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool) 12076 func (_SeigManagerI *SeigManagerISession) SetCommissionRate(rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) { 12077 return _SeigManagerI.Contract.SetCommissionRate(&_SeigManagerI.TransactOpts, rootchain, commission, isCommissionRateNegative) 12078 } 12079 12080 // SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66. 12081 // 12082 // Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool) 12083 func (_SeigManagerI *SeigManagerITransactorSession) SetCommissionRate(rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) { 12084 return _SeigManagerI.Contract.SetCommissionRate(&_SeigManagerI.TransactOpts, rootchain, commission, isCommissionRateNegative) 12085 } 12086 12087 // SeigTokenABI is the input ABI used to generate the binding from. 12088 const SeigTokenABI = "[{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"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\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"INTERFACE_ID_ON_APPROVE\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"approveAndCall\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"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\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigManager\",\"outputs\":[{\"internalType\":\"contractSeigManagerI\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"contractSeigManagerI\",\"name\":\"_seigManager\",\"type\":\"address\"}],\"name\":\"setSeigManager\",\"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\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"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\"}]" 12089 12090 // SeigTokenFuncSigs maps the 4-byte function signature to its string representation. 12091 var SeigTokenFuncSigs = map[string]string{ 12092 "6cd28f9a": "INTERFACE_ID_ON_APPROVE()", 12093 "dd62ed3e": "allowance(address,address)", 12094 "095ea7b3": "approve(address,uint256)", 12095 "cae9ca51": "approveAndCall(address,uint256,bytes)", 12096 "70a08231": "balanceOf(address)", 12097 "a457c2d7": "decreaseAllowance(address,uint256)", 12098 "39509351": "increaseAllowance(address,uint256)", 12099 "8f32d59b": "isOwner()", 12100 "8da5cb5b": "owner()", 12101 "5f112c68": "renounceMinter(address)", 12102 "715018a6": "renounceOwnership()", 12103 "38bf3cfa": "renounceOwnership(address)", 12104 "41eb24bb": "renouncePauser(address)", 12105 "6fb7f558": "seigManager()", 12106 "7657f20a": "setSeigManager(address)", 12107 "18160ddd": "totalSupply()", 12108 "a9059cbb": "transfer(address,uint256)", 12109 "23b872dd": "transferFrom(address,address,uint256)", 12110 "f2fde38b": "transferOwnership(address)", 12111 "6d435421": "transferOwnership(address,address)", 12112 } 12113 12114 // SeigTokenBin is the compiled bytecode used for deploying new contracts. 12115 var SeigTokenBin = "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" 12116 12117 // DeploySeigToken deploys a new Ethereum contract, binding an instance of SeigToken to it. 12118 func DeploySeigToken(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SeigToken, error) { 12119 parsed, err := abi.JSON(strings.NewReader(SeigTokenABI)) 12120 if err != nil { 12121 return common.Address{}, nil, nil, err 12122 } 12123 12124 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SeigTokenBin), backend) 12125 if err != nil { 12126 return common.Address{}, nil, nil, err 12127 } 12128 return address, tx, &SeigToken{SeigTokenCaller: SeigTokenCaller{contract: contract}, SeigTokenTransactor: SeigTokenTransactor{contract: contract}, SeigTokenFilterer: SeigTokenFilterer{contract: contract}}, nil 12129 } 12130 12131 // SeigToken is an auto generated Go binding around an Ethereum contract. 12132 type SeigToken struct { 12133 SeigTokenCaller // Read-only binding to the contract 12134 SeigTokenTransactor // Write-only binding to the contract 12135 SeigTokenFilterer // Log filterer for contract events 12136 } 12137 12138 // SeigTokenCaller is an auto generated read-only Go binding around an Ethereum contract. 12139 type SeigTokenCaller struct { 12140 contract *bind.BoundContract // Generic contract wrapper for the low level calls 12141 } 12142 12143 // SeigTokenTransactor is an auto generated write-only Go binding around an Ethereum contract. 12144 type SeigTokenTransactor struct { 12145 contract *bind.BoundContract // Generic contract wrapper for the low level calls 12146 } 12147 12148 // SeigTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 12149 type SeigTokenFilterer struct { 12150 contract *bind.BoundContract // Generic contract wrapper for the low level calls 12151 } 12152 12153 // SeigTokenSession is an auto generated Go binding around an Ethereum contract, 12154 // with pre-set call and transact options. 12155 type SeigTokenSession struct { 12156 Contract *SeigToken // Generic contract binding to set the session for 12157 CallOpts bind.CallOpts // Call options to use throughout this session 12158 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 12159 } 12160 12161 // SeigTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract, 12162 // with pre-set call options. 12163 type SeigTokenCallerSession struct { 12164 Contract *SeigTokenCaller // Generic contract caller binding to set the session for 12165 CallOpts bind.CallOpts // Call options to use throughout this session 12166 } 12167 12168 // SeigTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 12169 // with pre-set transact options. 12170 type SeigTokenTransactorSession struct { 12171 Contract *SeigTokenTransactor // Generic contract transactor binding to set the session for 12172 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 12173 } 12174 12175 // SeigTokenRaw is an auto generated low-level Go binding around an Ethereum contract. 12176 type SeigTokenRaw struct { 12177 Contract *SeigToken // Generic contract binding to access the raw methods on 12178 } 12179 12180 // SeigTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 12181 type SeigTokenCallerRaw struct { 12182 Contract *SeigTokenCaller // Generic read-only contract binding to access the raw methods on 12183 } 12184 12185 // SeigTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 12186 type SeigTokenTransactorRaw struct { 12187 Contract *SeigTokenTransactor // Generic write-only contract binding to access the raw methods on 12188 } 12189 12190 // NewSeigToken creates a new instance of SeigToken, bound to a specific deployed contract. 12191 func NewSeigToken(address common.Address, backend bind.ContractBackend) (*SeigToken, error) { 12192 contract, err := bindSeigToken(address, backend, backend, backend) 12193 if err != nil { 12194 return nil, err 12195 } 12196 return &SeigToken{SeigTokenCaller: SeigTokenCaller{contract: contract}, SeigTokenTransactor: SeigTokenTransactor{contract: contract}, SeigTokenFilterer: SeigTokenFilterer{contract: contract}}, nil 12197 } 12198 12199 // NewSeigTokenCaller creates a new read-only instance of SeigToken, bound to a specific deployed contract. 12200 func NewSeigTokenCaller(address common.Address, caller bind.ContractCaller) (*SeigTokenCaller, error) { 12201 contract, err := bindSeigToken(address, caller, nil, nil) 12202 if err != nil { 12203 return nil, err 12204 } 12205 return &SeigTokenCaller{contract: contract}, nil 12206 } 12207 12208 // NewSeigTokenTransactor creates a new write-only instance of SeigToken, bound to a specific deployed contract. 12209 func NewSeigTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*SeigTokenTransactor, error) { 12210 contract, err := bindSeigToken(address, nil, transactor, nil) 12211 if err != nil { 12212 return nil, err 12213 } 12214 return &SeigTokenTransactor{contract: contract}, nil 12215 } 12216 12217 // NewSeigTokenFilterer creates a new log filterer instance of SeigToken, bound to a specific deployed contract. 12218 func NewSeigTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*SeigTokenFilterer, error) { 12219 contract, err := bindSeigToken(address, nil, nil, filterer) 12220 if err != nil { 12221 return nil, err 12222 } 12223 return &SeigTokenFilterer{contract: contract}, nil 12224 } 12225 12226 // bindSeigToken binds a generic wrapper to an already deployed contract. 12227 func bindSeigToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 12228 parsed, err := abi.JSON(strings.NewReader(SeigTokenABI)) 12229 if err != nil { 12230 return nil, err 12231 } 12232 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 12233 } 12234 12235 // Call invokes the (constant) contract method with params as input values and 12236 // sets the output to result. The result type might be a single field for simple 12237 // returns, a slice of interfaces for anonymous returns and a struct for named 12238 // returns. 12239 func (_SeigToken *SeigTokenRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 12240 return _SeigToken.Contract.SeigTokenCaller.contract.Call(opts, result, method, params...) 12241 } 12242 12243 // Transfer initiates a plain transaction to move funds to the contract, calling 12244 // its default method if one is available. 12245 func (_SeigToken *SeigTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 12246 return _SeigToken.Contract.SeigTokenTransactor.contract.Transfer(opts) 12247 } 12248 12249 // Transact invokes the (paid) contract method with params as input values. 12250 func (_SeigToken *SeigTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 12251 return _SeigToken.Contract.SeigTokenTransactor.contract.Transact(opts, method, params...) 12252 } 12253 12254 // Call invokes the (constant) contract method with params as input values and 12255 // sets the output to result. The result type might be a single field for simple 12256 // returns, a slice of interfaces for anonymous returns and a struct for named 12257 // returns. 12258 func (_SeigToken *SeigTokenCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 12259 return _SeigToken.Contract.contract.Call(opts, result, method, params...) 12260 } 12261 12262 // Transfer initiates a plain transaction to move funds to the contract, calling 12263 // its default method if one is available. 12264 func (_SeigToken *SeigTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 12265 return _SeigToken.Contract.contract.Transfer(opts) 12266 } 12267 12268 // Transact invokes the (paid) contract method with params as input values. 12269 func (_SeigToken *SeigTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 12270 return _SeigToken.Contract.contract.Transact(opts, method, params...) 12271 } 12272 12273 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 12274 // 12275 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 12276 func (_SeigToken *SeigTokenCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) { 12277 var ( 12278 ret0 = new([4]byte) 12279 ) 12280 out := ret0 12281 err := _SeigToken.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE") 12282 return *ret0, err 12283 } 12284 12285 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 12286 // 12287 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 12288 func (_SeigToken *SeigTokenSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 12289 return _SeigToken.Contract.INTERFACEIDONAPPROVE(&_SeigToken.CallOpts) 12290 } 12291 12292 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 12293 // 12294 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 12295 func (_SeigToken *SeigTokenCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 12296 return _SeigToken.Contract.INTERFACEIDONAPPROVE(&_SeigToken.CallOpts) 12297 } 12298 12299 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 12300 // 12301 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 12302 func (_SeigToken *SeigTokenCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 12303 var ( 12304 ret0 = new(*big.Int) 12305 ) 12306 out := ret0 12307 err := _SeigToken.contract.Call(opts, out, "allowance", owner, spender) 12308 return *ret0, err 12309 } 12310 12311 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 12312 // 12313 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 12314 func (_SeigToken *SeigTokenSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 12315 return _SeigToken.Contract.Allowance(&_SeigToken.CallOpts, owner, spender) 12316 } 12317 12318 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 12319 // 12320 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 12321 func (_SeigToken *SeigTokenCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 12322 return _SeigToken.Contract.Allowance(&_SeigToken.CallOpts, owner, spender) 12323 } 12324 12325 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 12326 // 12327 // Solidity: function balanceOf(address account) constant returns(uint256) 12328 func (_SeigToken *SeigTokenCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 12329 var ( 12330 ret0 = new(*big.Int) 12331 ) 12332 out := ret0 12333 err := _SeigToken.contract.Call(opts, out, "balanceOf", account) 12334 return *ret0, err 12335 } 12336 12337 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 12338 // 12339 // Solidity: function balanceOf(address account) constant returns(uint256) 12340 func (_SeigToken *SeigTokenSession) BalanceOf(account common.Address) (*big.Int, error) { 12341 return _SeigToken.Contract.BalanceOf(&_SeigToken.CallOpts, account) 12342 } 12343 12344 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 12345 // 12346 // Solidity: function balanceOf(address account) constant returns(uint256) 12347 func (_SeigToken *SeigTokenCallerSession) BalanceOf(account common.Address) (*big.Int, error) { 12348 return _SeigToken.Contract.BalanceOf(&_SeigToken.CallOpts, account) 12349 } 12350 12351 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 12352 // 12353 // Solidity: function isOwner() constant returns(bool) 12354 func (_SeigToken *SeigTokenCaller) IsOwner(opts *bind.CallOpts) (bool, error) { 12355 var ( 12356 ret0 = new(bool) 12357 ) 12358 out := ret0 12359 err := _SeigToken.contract.Call(opts, out, "isOwner") 12360 return *ret0, err 12361 } 12362 12363 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 12364 // 12365 // Solidity: function isOwner() constant returns(bool) 12366 func (_SeigToken *SeigTokenSession) IsOwner() (bool, error) { 12367 return _SeigToken.Contract.IsOwner(&_SeigToken.CallOpts) 12368 } 12369 12370 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 12371 // 12372 // Solidity: function isOwner() constant returns(bool) 12373 func (_SeigToken *SeigTokenCallerSession) IsOwner() (bool, error) { 12374 return _SeigToken.Contract.IsOwner(&_SeigToken.CallOpts) 12375 } 12376 12377 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 12378 // 12379 // Solidity: function owner() constant returns(address) 12380 func (_SeigToken *SeigTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 12381 var ( 12382 ret0 = new(common.Address) 12383 ) 12384 out := ret0 12385 err := _SeigToken.contract.Call(opts, out, "owner") 12386 return *ret0, err 12387 } 12388 12389 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 12390 // 12391 // Solidity: function owner() constant returns(address) 12392 func (_SeigToken *SeigTokenSession) Owner() (common.Address, error) { 12393 return _SeigToken.Contract.Owner(&_SeigToken.CallOpts) 12394 } 12395 12396 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 12397 // 12398 // Solidity: function owner() constant returns(address) 12399 func (_SeigToken *SeigTokenCallerSession) Owner() (common.Address, error) { 12400 return _SeigToken.Contract.Owner(&_SeigToken.CallOpts) 12401 } 12402 12403 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 12404 // 12405 // Solidity: function seigManager() constant returns(address) 12406 func (_SeigToken *SeigTokenCaller) SeigManager(opts *bind.CallOpts) (common.Address, error) { 12407 var ( 12408 ret0 = new(common.Address) 12409 ) 12410 out := ret0 12411 err := _SeigToken.contract.Call(opts, out, "seigManager") 12412 return *ret0, err 12413 } 12414 12415 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 12416 // 12417 // Solidity: function seigManager() constant returns(address) 12418 func (_SeigToken *SeigTokenSession) SeigManager() (common.Address, error) { 12419 return _SeigToken.Contract.SeigManager(&_SeigToken.CallOpts) 12420 } 12421 12422 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 12423 // 12424 // Solidity: function seigManager() constant returns(address) 12425 func (_SeigToken *SeigTokenCallerSession) SeigManager() (common.Address, error) { 12426 return _SeigToken.Contract.SeigManager(&_SeigToken.CallOpts) 12427 } 12428 12429 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 12430 // 12431 // Solidity: function totalSupply() constant returns(uint256) 12432 func (_SeigToken *SeigTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 12433 var ( 12434 ret0 = new(*big.Int) 12435 ) 12436 out := ret0 12437 err := _SeigToken.contract.Call(opts, out, "totalSupply") 12438 return *ret0, err 12439 } 12440 12441 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 12442 // 12443 // Solidity: function totalSupply() constant returns(uint256) 12444 func (_SeigToken *SeigTokenSession) TotalSupply() (*big.Int, error) { 12445 return _SeigToken.Contract.TotalSupply(&_SeigToken.CallOpts) 12446 } 12447 12448 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 12449 // 12450 // Solidity: function totalSupply() constant returns(uint256) 12451 func (_SeigToken *SeigTokenCallerSession) TotalSupply() (*big.Int, error) { 12452 return _SeigToken.Contract.TotalSupply(&_SeigToken.CallOpts) 12453 } 12454 12455 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 12456 // 12457 // Solidity: function approve(address spender, uint256 amount) returns(bool) 12458 func (_SeigToken *SeigTokenTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 12459 return _SeigToken.contract.Transact(opts, "approve", spender, amount) 12460 } 12461 12462 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 12463 // 12464 // Solidity: function approve(address spender, uint256 amount) returns(bool) 12465 func (_SeigToken *SeigTokenSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 12466 return _SeigToken.Contract.Approve(&_SeigToken.TransactOpts, spender, amount) 12467 } 12468 12469 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 12470 // 12471 // Solidity: function approve(address spender, uint256 amount) returns(bool) 12472 func (_SeigToken *SeigTokenTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 12473 return _SeigToken.Contract.Approve(&_SeigToken.TransactOpts, spender, amount) 12474 } 12475 12476 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 12477 // 12478 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 12479 func (_SeigToken *SeigTokenTransactor) ApproveAndCall(opts *bind.TransactOpts, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 12480 return _SeigToken.contract.Transact(opts, "approveAndCall", spender, amount, data) 12481 } 12482 12483 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 12484 // 12485 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 12486 func (_SeigToken *SeigTokenSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 12487 return _SeigToken.Contract.ApproveAndCall(&_SeigToken.TransactOpts, spender, amount, data) 12488 } 12489 12490 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 12491 // 12492 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 12493 func (_SeigToken *SeigTokenTransactorSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 12494 return _SeigToken.Contract.ApproveAndCall(&_SeigToken.TransactOpts, spender, amount, data) 12495 } 12496 12497 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 12498 // 12499 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 12500 func (_SeigToken *SeigTokenTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 12501 return _SeigToken.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) 12502 } 12503 12504 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 12505 // 12506 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 12507 func (_SeigToken *SeigTokenSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 12508 return _SeigToken.Contract.DecreaseAllowance(&_SeigToken.TransactOpts, spender, subtractedValue) 12509 } 12510 12511 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 12512 // 12513 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 12514 func (_SeigToken *SeigTokenTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 12515 return _SeigToken.Contract.DecreaseAllowance(&_SeigToken.TransactOpts, spender, subtractedValue) 12516 } 12517 12518 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 12519 // 12520 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 12521 func (_SeigToken *SeigTokenTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 12522 return _SeigToken.contract.Transact(opts, "increaseAllowance", spender, addedValue) 12523 } 12524 12525 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 12526 // 12527 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 12528 func (_SeigToken *SeigTokenSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 12529 return _SeigToken.Contract.IncreaseAllowance(&_SeigToken.TransactOpts, spender, addedValue) 12530 } 12531 12532 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 12533 // 12534 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 12535 func (_SeigToken *SeigTokenTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 12536 return _SeigToken.Contract.IncreaseAllowance(&_SeigToken.TransactOpts, spender, addedValue) 12537 } 12538 12539 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 12540 // 12541 // Solidity: function renounceMinter(address target) returns() 12542 func (_SeigToken *SeigTokenTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 12543 return _SeigToken.contract.Transact(opts, "renounceMinter", target) 12544 } 12545 12546 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 12547 // 12548 // Solidity: function renounceMinter(address target) returns() 12549 func (_SeigToken *SeigTokenSession) RenounceMinter(target common.Address) (*types.Transaction, error) { 12550 return _SeigToken.Contract.RenounceMinter(&_SeigToken.TransactOpts, target) 12551 } 12552 12553 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 12554 // 12555 // Solidity: function renounceMinter(address target) returns() 12556 func (_SeigToken *SeigTokenTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) { 12557 return _SeigToken.Contract.RenounceMinter(&_SeigToken.TransactOpts, target) 12558 } 12559 12560 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 12561 // 12562 // Solidity: function renounceOwnership(address target) returns() 12563 func (_SeigToken *SeigTokenTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 12564 return _SeigToken.contract.Transact(opts, "renounceOwnership", target) 12565 } 12566 12567 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 12568 // 12569 // Solidity: function renounceOwnership(address target) returns() 12570 func (_SeigToken *SeigTokenSession) RenounceOwnership(target common.Address) (*types.Transaction, error) { 12571 return _SeigToken.Contract.RenounceOwnership(&_SeigToken.TransactOpts, target) 12572 } 12573 12574 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 12575 // 12576 // Solidity: function renounceOwnership(address target) returns() 12577 func (_SeigToken *SeigTokenTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) { 12578 return _SeigToken.Contract.RenounceOwnership(&_SeigToken.TransactOpts, target) 12579 } 12580 12581 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 12582 // 12583 // Solidity: function renounceOwnership() returns() 12584 func (_SeigToken *SeigTokenTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) { 12585 return _SeigToken.contract.Transact(opts, "renounceOwnership0") 12586 } 12587 12588 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 12589 // 12590 // Solidity: function renounceOwnership() returns() 12591 func (_SeigToken *SeigTokenSession) RenounceOwnership0() (*types.Transaction, error) { 12592 return _SeigToken.Contract.RenounceOwnership0(&_SeigToken.TransactOpts) 12593 } 12594 12595 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 12596 // 12597 // Solidity: function renounceOwnership() returns() 12598 func (_SeigToken *SeigTokenTransactorSession) RenounceOwnership0() (*types.Transaction, error) { 12599 return _SeigToken.Contract.RenounceOwnership0(&_SeigToken.TransactOpts) 12600 } 12601 12602 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 12603 // 12604 // Solidity: function renouncePauser(address target) returns() 12605 func (_SeigToken *SeigTokenTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 12606 return _SeigToken.contract.Transact(opts, "renouncePauser", target) 12607 } 12608 12609 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 12610 // 12611 // Solidity: function renouncePauser(address target) returns() 12612 func (_SeigToken *SeigTokenSession) RenouncePauser(target common.Address) (*types.Transaction, error) { 12613 return _SeigToken.Contract.RenouncePauser(&_SeigToken.TransactOpts, target) 12614 } 12615 12616 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 12617 // 12618 // Solidity: function renouncePauser(address target) returns() 12619 func (_SeigToken *SeigTokenTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) { 12620 return _SeigToken.Contract.RenouncePauser(&_SeigToken.TransactOpts, target) 12621 } 12622 12623 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 12624 // 12625 // Solidity: function setSeigManager(address _seigManager) returns() 12626 func (_SeigToken *SeigTokenTransactor) SetSeigManager(opts *bind.TransactOpts, _seigManager common.Address) (*types.Transaction, error) { 12627 return _SeigToken.contract.Transact(opts, "setSeigManager", _seigManager) 12628 } 12629 12630 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 12631 // 12632 // Solidity: function setSeigManager(address _seigManager) returns() 12633 func (_SeigToken *SeigTokenSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) { 12634 return _SeigToken.Contract.SetSeigManager(&_SeigToken.TransactOpts, _seigManager) 12635 } 12636 12637 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 12638 // 12639 // Solidity: function setSeigManager(address _seigManager) returns() 12640 func (_SeigToken *SeigTokenTransactorSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) { 12641 return _SeigToken.Contract.SetSeigManager(&_SeigToken.TransactOpts, _seigManager) 12642 } 12643 12644 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 12645 // 12646 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 12647 func (_SeigToken *SeigTokenTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 12648 return _SeigToken.contract.Transact(opts, "transfer", recipient, amount) 12649 } 12650 12651 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 12652 // 12653 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 12654 func (_SeigToken *SeigTokenSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 12655 return _SeigToken.Contract.Transfer(&_SeigToken.TransactOpts, recipient, amount) 12656 } 12657 12658 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 12659 // 12660 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 12661 func (_SeigToken *SeigTokenTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 12662 return _SeigToken.Contract.Transfer(&_SeigToken.TransactOpts, recipient, amount) 12663 } 12664 12665 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 12666 // 12667 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 12668 func (_SeigToken *SeigTokenTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 12669 return _SeigToken.contract.Transact(opts, "transferFrom", sender, recipient, amount) 12670 } 12671 12672 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 12673 // 12674 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 12675 func (_SeigToken *SeigTokenSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 12676 return _SeigToken.Contract.TransferFrom(&_SeigToken.TransactOpts, sender, recipient, amount) 12677 } 12678 12679 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 12680 // 12681 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 12682 func (_SeigToken *SeigTokenTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 12683 return _SeigToken.Contract.TransferFrom(&_SeigToken.TransactOpts, sender, recipient, amount) 12684 } 12685 12686 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 12687 // 12688 // Solidity: function transferOwnership(address target, address newOwner) returns() 12689 func (_SeigToken *SeigTokenTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) { 12690 return _SeigToken.contract.Transact(opts, "transferOwnership", target, newOwner) 12691 } 12692 12693 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 12694 // 12695 // Solidity: function transferOwnership(address target, address newOwner) returns() 12696 func (_SeigToken *SeigTokenSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) { 12697 return _SeigToken.Contract.TransferOwnership(&_SeigToken.TransactOpts, target, newOwner) 12698 } 12699 12700 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 12701 // 12702 // Solidity: function transferOwnership(address target, address newOwner) returns() 12703 func (_SeigToken *SeigTokenTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) { 12704 return _SeigToken.Contract.TransferOwnership(&_SeigToken.TransactOpts, target, newOwner) 12705 } 12706 12707 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 12708 // 12709 // Solidity: function transferOwnership(address newOwner) returns() 12710 func (_SeigToken *SeigTokenTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 12711 return _SeigToken.contract.Transact(opts, "transferOwnership0", newOwner) 12712 } 12713 12714 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 12715 // 12716 // Solidity: function transferOwnership(address newOwner) returns() 12717 func (_SeigToken *SeigTokenSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) { 12718 return _SeigToken.Contract.TransferOwnership0(&_SeigToken.TransactOpts, newOwner) 12719 } 12720 12721 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 12722 // 12723 // Solidity: function transferOwnership(address newOwner) returns() 12724 func (_SeigToken *SeigTokenTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) { 12725 return _SeigToken.Contract.TransferOwnership0(&_SeigToken.TransactOpts, newOwner) 12726 } 12727 12728 // SeigTokenApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the SeigToken contract. 12729 type SeigTokenApprovalIterator struct { 12730 Event *SeigTokenApproval // Event containing the contract specifics and raw log 12731 12732 contract *bind.BoundContract // Generic contract to use for unpacking event data 12733 event string // Event name to use for unpacking event data 12734 12735 logs chan types.Log // Log channel receiving the found contract events 12736 sub ethereum.Subscription // Subscription for errors, completion and termination 12737 done bool // Whether the subscription completed delivering logs 12738 fail error // Occurred error to stop iteration 12739 } 12740 12741 // Next advances the iterator to the subsequent event, returning whether there 12742 // are any more events found. In case of a retrieval or parsing error, false is 12743 // returned and Error() can be queried for the exact failure. 12744 func (it *SeigTokenApprovalIterator) Next() bool { 12745 // If the iterator failed, stop iterating 12746 if it.fail != nil { 12747 return false 12748 } 12749 // If the iterator completed, deliver directly whatever's available 12750 if it.done { 12751 select { 12752 case log := <-it.logs: 12753 it.Event = new(SeigTokenApproval) 12754 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 12755 it.fail = err 12756 return false 12757 } 12758 it.Event.Raw = log 12759 return true 12760 12761 default: 12762 return false 12763 } 12764 } 12765 // Iterator still in progress, wait for either a data or an error event 12766 select { 12767 case log := <-it.logs: 12768 it.Event = new(SeigTokenApproval) 12769 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 12770 it.fail = err 12771 return false 12772 } 12773 it.Event.Raw = log 12774 return true 12775 12776 case err := <-it.sub.Err(): 12777 it.done = true 12778 it.fail = err 12779 return it.Next() 12780 } 12781 } 12782 12783 // Error returns any retrieval or parsing error occurred during filtering. 12784 func (it *SeigTokenApprovalIterator) Error() error { 12785 return it.fail 12786 } 12787 12788 // Close terminates the iteration process, releasing any pending underlying 12789 // resources. 12790 func (it *SeigTokenApprovalIterator) Close() error { 12791 it.sub.Unsubscribe() 12792 return nil 12793 } 12794 12795 // SeigTokenApproval represents a Approval event raised by the SeigToken contract. 12796 type SeigTokenApproval struct { 12797 Owner common.Address 12798 Spender common.Address 12799 Value *big.Int 12800 Raw types.Log // Blockchain specific contextual infos 12801 } 12802 12803 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 12804 // 12805 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 12806 func (_SeigToken *SeigTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*SeigTokenApprovalIterator, error) { 12807 12808 var ownerRule []interface{} 12809 for _, ownerItem := range owner { 12810 ownerRule = append(ownerRule, ownerItem) 12811 } 12812 var spenderRule []interface{} 12813 for _, spenderItem := range spender { 12814 spenderRule = append(spenderRule, spenderItem) 12815 } 12816 12817 logs, sub, err := _SeigToken.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 12818 if err != nil { 12819 return nil, err 12820 } 12821 return &SeigTokenApprovalIterator{contract: _SeigToken.contract, event: "Approval", logs: logs, sub: sub}, nil 12822 } 12823 12824 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 12825 // 12826 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 12827 func (_SeigToken *SeigTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *SeigTokenApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 12828 12829 var ownerRule []interface{} 12830 for _, ownerItem := range owner { 12831 ownerRule = append(ownerRule, ownerItem) 12832 } 12833 var spenderRule []interface{} 12834 for _, spenderItem := range spender { 12835 spenderRule = append(spenderRule, spenderItem) 12836 } 12837 12838 logs, sub, err := _SeigToken.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 12839 if err != nil { 12840 return nil, err 12841 } 12842 return event.NewSubscription(func(quit <-chan struct{}) error { 12843 defer sub.Unsubscribe() 12844 for { 12845 select { 12846 case log := <-logs: 12847 // New log arrived, parse the event and forward to the user 12848 event := new(SeigTokenApproval) 12849 if err := _SeigToken.contract.UnpackLog(event, "Approval", log); err != nil { 12850 return err 12851 } 12852 event.Raw = log 12853 12854 select { 12855 case sink <- event: 12856 case err := <-sub.Err(): 12857 return err 12858 case <-quit: 12859 return nil 12860 } 12861 case err := <-sub.Err(): 12862 return err 12863 case <-quit: 12864 return nil 12865 } 12866 } 12867 }), nil 12868 } 12869 12870 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 12871 // 12872 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 12873 func (_SeigToken *SeigTokenFilterer) ParseApproval(log types.Log) (*SeigTokenApproval, error) { 12874 event := new(SeigTokenApproval) 12875 if err := _SeigToken.contract.UnpackLog(event, "Approval", log); err != nil { 12876 return nil, err 12877 } 12878 return event, nil 12879 } 12880 12881 // SeigTokenOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the SeigToken contract. 12882 type SeigTokenOwnershipTransferredIterator struct { 12883 Event *SeigTokenOwnershipTransferred // Event containing the contract specifics and raw log 12884 12885 contract *bind.BoundContract // Generic contract to use for unpacking event data 12886 event string // Event name to use for unpacking event data 12887 12888 logs chan types.Log // Log channel receiving the found contract events 12889 sub ethereum.Subscription // Subscription for errors, completion and termination 12890 done bool // Whether the subscription completed delivering logs 12891 fail error // Occurred error to stop iteration 12892 } 12893 12894 // Next advances the iterator to the subsequent event, returning whether there 12895 // are any more events found. In case of a retrieval or parsing error, false is 12896 // returned and Error() can be queried for the exact failure. 12897 func (it *SeigTokenOwnershipTransferredIterator) Next() bool { 12898 // If the iterator failed, stop iterating 12899 if it.fail != nil { 12900 return false 12901 } 12902 // If the iterator completed, deliver directly whatever's available 12903 if it.done { 12904 select { 12905 case log := <-it.logs: 12906 it.Event = new(SeigTokenOwnershipTransferred) 12907 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 12908 it.fail = err 12909 return false 12910 } 12911 it.Event.Raw = log 12912 return true 12913 12914 default: 12915 return false 12916 } 12917 } 12918 // Iterator still in progress, wait for either a data or an error event 12919 select { 12920 case log := <-it.logs: 12921 it.Event = new(SeigTokenOwnershipTransferred) 12922 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 12923 it.fail = err 12924 return false 12925 } 12926 it.Event.Raw = log 12927 return true 12928 12929 case err := <-it.sub.Err(): 12930 it.done = true 12931 it.fail = err 12932 return it.Next() 12933 } 12934 } 12935 12936 // Error returns any retrieval or parsing error occurred during filtering. 12937 func (it *SeigTokenOwnershipTransferredIterator) Error() error { 12938 return it.fail 12939 } 12940 12941 // Close terminates the iteration process, releasing any pending underlying 12942 // resources. 12943 func (it *SeigTokenOwnershipTransferredIterator) Close() error { 12944 it.sub.Unsubscribe() 12945 return nil 12946 } 12947 12948 // SeigTokenOwnershipTransferred represents a OwnershipTransferred event raised by the SeigToken contract. 12949 type SeigTokenOwnershipTransferred struct { 12950 PreviousOwner common.Address 12951 NewOwner common.Address 12952 Raw types.Log // Blockchain specific contextual infos 12953 } 12954 12955 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 12956 // 12957 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 12958 func (_SeigToken *SeigTokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*SeigTokenOwnershipTransferredIterator, error) { 12959 12960 var previousOwnerRule []interface{} 12961 for _, previousOwnerItem := range previousOwner { 12962 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 12963 } 12964 var newOwnerRule []interface{} 12965 for _, newOwnerItem := range newOwner { 12966 newOwnerRule = append(newOwnerRule, newOwnerItem) 12967 } 12968 12969 logs, sub, err := _SeigToken.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 12970 if err != nil { 12971 return nil, err 12972 } 12973 return &SeigTokenOwnershipTransferredIterator{contract: _SeigToken.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 12974 } 12975 12976 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 12977 // 12978 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 12979 func (_SeigToken *SeigTokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SeigTokenOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 12980 12981 var previousOwnerRule []interface{} 12982 for _, previousOwnerItem := range previousOwner { 12983 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 12984 } 12985 var newOwnerRule []interface{} 12986 for _, newOwnerItem := range newOwner { 12987 newOwnerRule = append(newOwnerRule, newOwnerItem) 12988 } 12989 12990 logs, sub, err := _SeigToken.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 12991 if err != nil { 12992 return nil, err 12993 } 12994 return event.NewSubscription(func(quit <-chan struct{}) error { 12995 defer sub.Unsubscribe() 12996 for { 12997 select { 12998 case log := <-logs: 12999 // New log arrived, parse the event and forward to the user 13000 event := new(SeigTokenOwnershipTransferred) 13001 if err := _SeigToken.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 13002 return err 13003 } 13004 event.Raw = log 13005 13006 select { 13007 case sink <- event: 13008 case err := <-sub.Err(): 13009 return err 13010 case <-quit: 13011 return nil 13012 } 13013 case err := <-sub.Err(): 13014 return err 13015 case <-quit: 13016 return nil 13017 } 13018 } 13019 }), nil 13020 } 13021 13022 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 13023 // 13024 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 13025 func (_SeigToken *SeigTokenFilterer) ParseOwnershipTransferred(log types.Log) (*SeigTokenOwnershipTransferred, error) { 13026 event := new(SeigTokenOwnershipTransferred) 13027 if err := _SeigToken.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 13028 return nil, err 13029 } 13030 return event, nil 13031 } 13032 13033 // SeigTokenTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the SeigToken contract. 13034 type SeigTokenTransferIterator struct { 13035 Event *SeigTokenTransfer // Event containing the contract specifics and raw log 13036 13037 contract *bind.BoundContract // Generic contract to use for unpacking event data 13038 event string // Event name to use for unpacking event data 13039 13040 logs chan types.Log // Log channel receiving the found contract events 13041 sub ethereum.Subscription // Subscription for errors, completion and termination 13042 done bool // Whether the subscription completed delivering logs 13043 fail error // Occurred error to stop iteration 13044 } 13045 13046 // Next advances the iterator to the subsequent event, returning whether there 13047 // are any more events found. In case of a retrieval or parsing error, false is 13048 // returned and Error() can be queried for the exact failure. 13049 func (it *SeigTokenTransferIterator) Next() bool { 13050 // If the iterator failed, stop iterating 13051 if it.fail != nil { 13052 return false 13053 } 13054 // If the iterator completed, deliver directly whatever's available 13055 if it.done { 13056 select { 13057 case log := <-it.logs: 13058 it.Event = new(SeigTokenTransfer) 13059 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 13060 it.fail = err 13061 return false 13062 } 13063 it.Event.Raw = log 13064 return true 13065 13066 default: 13067 return false 13068 } 13069 } 13070 // Iterator still in progress, wait for either a data or an error event 13071 select { 13072 case log := <-it.logs: 13073 it.Event = new(SeigTokenTransfer) 13074 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 13075 it.fail = err 13076 return false 13077 } 13078 it.Event.Raw = log 13079 return true 13080 13081 case err := <-it.sub.Err(): 13082 it.done = true 13083 it.fail = err 13084 return it.Next() 13085 } 13086 } 13087 13088 // Error returns any retrieval or parsing error occurred during filtering. 13089 func (it *SeigTokenTransferIterator) Error() error { 13090 return it.fail 13091 } 13092 13093 // Close terminates the iteration process, releasing any pending underlying 13094 // resources. 13095 func (it *SeigTokenTransferIterator) Close() error { 13096 it.sub.Unsubscribe() 13097 return nil 13098 } 13099 13100 // SeigTokenTransfer represents a Transfer event raised by the SeigToken contract. 13101 type SeigTokenTransfer struct { 13102 From common.Address 13103 To common.Address 13104 Value *big.Int 13105 Raw types.Log // Blockchain specific contextual infos 13106 } 13107 13108 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 13109 // 13110 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 13111 func (_SeigToken *SeigTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*SeigTokenTransferIterator, error) { 13112 13113 var fromRule []interface{} 13114 for _, fromItem := range from { 13115 fromRule = append(fromRule, fromItem) 13116 } 13117 var toRule []interface{} 13118 for _, toItem := range to { 13119 toRule = append(toRule, toItem) 13120 } 13121 13122 logs, sub, err := _SeigToken.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 13123 if err != nil { 13124 return nil, err 13125 } 13126 return &SeigTokenTransferIterator{contract: _SeigToken.contract, event: "Transfer", logs: logs, sub: sub}, nil 13127 } 13128 13129 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 13130 // 13131 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 13132 func (_SeigToken *SeigTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *SeigTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 13133 13134 var fromRule []interface{} 13135 for _, fromItem := range from { 13136 fromRule = append(fromRule, fromItem) 13137 } 13138 var toRule []interface{} 13139 for _, toItem := range to { 13140 toRule = append(toRule, toItem) 13141 } 13142 13143 logs, sub, err := _SeigToken.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 13144 if err != nil { 13145 return nil, err 13146 } 13147 return event.NewSubscription(func(quit <-chan struct{}) error { 13148 defer sub.Unsubscribe() 13149 for { 13150 select { 13151 case log := <-logs: 13152 // New log arrived, parse the event and forward to the user 13153 event := new(SeigTokenTransfer) 13154 if err := _SeigToken.contract.UnpackLog(event, "Transfer", log); err != nil { 13155 return err 13156 } 13157 event.Raw = log 13158 13159 select { 13160 case sink <- event: 13161 case err := <-sub.Err(): 13162 return err 13163 case <-quit: 13164 return nil 13165 } 13166 case err := <-sub.Err(): 13167 return err 13168 case <-quit: 13169 return nil 13170 } 13171 } 13172 }), nil 13173 } 13174 13175 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 13176 // 13177 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 13178 func (_SeigToken *SeigTokenFilterer) ParseTransfer(log types.Log) (*SeigTokenTransfer, error) { 13179 event := new(SeigTokenTransfer) 13180 if err := _SeigToken.contract.UnpackLog(event, "Transfer", log); err != nil { 13181 return nil, err 13182 } 13183 return event, nil 13184 } 13185 13186 // WTONABI is the input ABI used to generate the binding from. 13187 const WTONABI = "[{\"inputs\":[{\"internalType\":\"contractERC20Mintable\",\"name\":\"_ton\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Approval\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterAdded\",\"type\":\"event\"},{\"anonymous\":false,\"inputs\":[{\"indexed\":true,\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"MinterRemoved\",\"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\":true,\"internalType\":\"address\",\"name\":\"from\",\"type\":\"address\"},{\"indexed\":true,\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"indexed\":false,\"internalType\":\"uint256\",\"name\":\"value\",\"type\":\"uint256\"}],\"name\":\"Transfer\",\"type\":\"event\"},{\"constant\":true,\"inputs\":[],\"name\":\"INTERFACE_ID_ON_APPROVE\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"addMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"}],\"name\":\"allowance\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"approve\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"approveAndCall\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"balanceOf\",\"outputs\":[{\"internalType\":\"uint256\",\"name\":\"\",\"type\":\"uint256\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burn\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"burnFrom\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"decimals\",\"outputs\":[{\"internalType\":\"uint8\",\"name\":\"\",\"type\":\"uint8\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"subtractedValue\",\"type\":\"uint256\"}],\"name\":\"decreaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"addedValue\",\"type\":\"uint256\"}],\"name\":\"increaseAllowance\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"address\",\"name\":\"account\",\"type\":\"address\"}],\"name\":\"isMinter\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"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\":\"account\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"mint\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"name\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"owner\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"spender\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tonAmount\",\"type\":\"uint256\"},{\"internalType\":\"bytes\",\"name\":\"data\",\"type\":\"bytes\"}],\"name\":\"onApprove\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"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\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[],\"name\":\"renounceOwnership\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"}],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"seigManager\",\"outputs\":[{\"internalType\":\"contractSeigManagerI\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"contractSeigManagerI\",\"name\":\"_seigManager\",\"type\":\"address\"}],\"name\":\"setSeigManager\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[{\"internalType\":\"bytes4\",\"name\":\"interfaceId\",\"type\":\"bytes4\"}],\"name\":\"supportsInterface\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"tonAmount\",\"type\":\"uint256\"}],\"name\":\"swapFromTON\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"tonAmount\",\"type\":\"uint256\"}],\"name\":\"swapFromTONAndTransfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"name\":\"swapToTON\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"to\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"wtonAmount\",\"type\":\"uint256\"}],\"name\":\"swapToTONAndTransfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"symbol\",\"outputs\":[{\"internalType\":\"string\",\"name\":\"\",\"type\":\"string\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"},{\"constant\":true,\"inputs\":[],\"name\":\"ton\",\"outputs\":[{\"internalType\":\"contractERC20Mintable\",\"name\":\"\",\"type\":\"address\"}],\"payable\":false,\"stateMutability\":\"view\",\"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\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transfer\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"sender\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"recipient\",\"type\":\"address\"},{\"internalType\":\"uint256\",\"name\":\"amount\",\"type\":\"uint256\"}],\"name\":\"transferFrom\",\"outputs\":[{\"internalType\":\"bool\",\"name\":\"\",\"type\":\"bool\"}],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"},{\"constant\":false,\"inputs\":[{\"internalType\":\"address\",\"name\":\"target\",\"type\":\"address\"},{\"internalType\":\"address\",\"name\":\"newOwner\",\"type\":\"address\"}],\"name\":\"transferOwnership\",\"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\"}]" 13188 13189 // WTONFuncSigs maps the 4-byte function signature to its string representation. 13190 var WTONFuncSigs = map[string]string{ 13191 "6cd28f9a": "INTERFACE_ID_ON_APPROVE()", 13192 "983b2d56": "addMinter(address)", 13193 "dd62ed3e": "allowance(address,address)", 13194 "095ea7b3": "approve(address,uint256)", 13195 "cae9ca51": "approveAndCall(address,uint256,bytes)", 13196 "70a08231": "balanceOf(address)", 13197 "42966c68": "burn(uint256)", 13198 "79cc6790": "burnFrom(address,uint256)", 13199 "313ce567": "decimals()", 13200 "a457c2d7": "decreaseAllowance(address,uint256)", 13201 "39509351": "increaseAllowance(address,uint256)", 13202 "aa271e1a": "isMinter(address)", 13203 "8f32d59b": "isOwner()", 13204 "40c10f19": "mint(address,uint256)", 13205 "06fdde03": "name()", 13206 "4273ca16": "onApprove(address,address,uint256,bytes)", 13207 "8da5cb5b": "owner()", 13208 "98650275": "renounceMinter()", 13209 "5f112c68": "renounceMinter(address)", 13210 "715018a6": "renounceOwnership()", 13211 "38bf3cfa": "renounceOwnership(address)", 13212 "41eb24bb": "renouncePauser(address)", 13213 "6fb7f558": "seigManager()", 13214 "7657f20a": "setSeigManager(address)", 13215 "01ffc9a7": "supportsInterface(bytes4)", 13216 "e34869d7": "swapFromTON(uint256)", 13217 "588420b7": "swapFromTONAndTransfer(address,uint256)", 13218 "f53fe70f": "swapToTON(uint256)", 13219 "e3b99e85": "swapToTONAndTransfer(address,uint256)", 13220 "95d89b41": "symbol()", 13221 "cc48b947": "ton()", 13222 "18160ddd": "totalSupply()", 13223 "a9059cbb": "transfer(address,uint256)", 13224 "23b872dd": "transferFrom(address,address,uint256)", 13225 "f2fde38b": "transferOwnership(address)", 13226 "6d435421": "transferOwnership(address,address)", 13227 } 13228 13229 // WTONBin is the compiled bytecode used for deploying new contracts. 13230 var WTONBin = "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" 13231 13232 // DeployWTON deploys a new Ethereum contract, binding an instance of WTON to it. 13233 func DeployWTON(auth *bind.TransactOpts, backend bind.ContractBackend, _ton common.Address) (common.Address, *types.Transaction, *WTON, error) { 13234 parsed, err := abi.JSON(strings.NewReader(WTONABI)) 13235 if err != nil { 13236 return common.Address{}, nil, nil, err 13237 } 13238 13239 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(WTONBin), backend, _ton) 13240 if err != nil { 13241 return common.Address{}, nil, nil, err 13242 } 13243 return address, tx, &WTON{WTONCaller: WTONCaller{contract: contract}, WTONTransactor: WTONTransactor{contract: contract}, WTONFilterer: WTONFilterer{contract: contract}}, nil 13244 } 13245 13246 // WTON is an auto generated Go binding around an Ethereum contract. 13247 type WTON struct { 13248 WTONCaller // Read-only binding to the contract 13249 WTONTransactor // Write-only binding to the contract 13250 WTONFilterer // Log filterer for contract events 13251 } 13252 13253 // WTONCaller is an auto generated read-only Go binding around an Ethereum contract. 13254 type WTONCaller struct { 13255 contract *bind.BoundContract // Generic contract wrapper for the low level calls 13256 } 13257 13258 // WTONTransactor is an auto generated write-only Go binding around an Ethereum contract. 13259 type WTONTransactor struct { 13260 contract *bind.BoundContract // Generic contract wrapper for the low level calls 13261 } 13262 13263 // WTONFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 13264 type WTONFilterer struct { 13265 contract *bind.BoundContract // Generic contract wrapper for the low level calls 13266 } 13267 13268 // WTONSession is an auto generated Go binding around an Ethereum contract, 13269 // with pre-set call and transact options. 13270 type WTONSession struct { 13271 Contract *WTON // Generic contract binding to set the session for 13272 CallOpts bind.CallOpts // Call options to use throughout this session 13273 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 13274 } 13275 13276 // WTONCallerSession is an auto generated read-only Go binding around an Ethereum contract, 13277 // with pre-set call options. 13278 type WTONCallerSession struct { 13279 Contract *WTONCaller // Generic contract caller binding to set the session for 13280 CallOpts bind.CallOpts // Call options to use throughout this session 13281 } 13282 13283 // WTONTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 13284 // with pre-set transact options. 13285 type WTONTransactorSession struct { 13286 Contract *WTONTransactor // Generic contract transactor binding to set the session for 13287 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 13288 } 13289 13290 // WTONRaw is an auto generated low-level Go binding around an Ethereum contract. 13291 type WTONRaw struct { 13292 Contract *WTON // Generic contract binding to access the raw methods on 13293 } 13294 13295 // WTONCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 13296 type WTONCallerRaw struct { 13297 Contract *WTONCaller // Generic read-only contract binding to access the raw methods on 13298 } 13299 13300 // WTONTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 13301 type WTONTransactorRaw struct { 13302 Contract *WTONTransactor // Generic write-only contract binding to access the raw methods on 13303 } 13304 13305 // NewWTON creates a new instance of WTON, bound to a specific deployed contract. 13306 func NewWTON(address common.Address, backend bind.ContractBackend) (*WTON, error) { 13307 contract, err := bindWTON(address, backend, backend, backend) 13308 if err != nil { 13309 return nil, err 13310 } 13311 return &WTON{WTONCaller: WTONCaller{contract: contract}, WTONTransactor: WTONTransactor{contract: contract}, WTONFilterer: WTONFilterer{contract: contract}}, nil 13312 } 13313 13314 // NewWTONCaller creates a new read-only instance of WTON, bound to a specific deployed contract. 13315 func NewWTONCaller(address common.Address, caller bind.ContractCaller) (*WTONCaller, error) { 13316 contract, err := bindWTON(address, caller, nil, nil) 13317 if err != nil { 13318 return nil, err 13319 } 13320 return &WTONCaller{contract: contract}, nil 13321 } 13322 13323 // NewWTONTransactor creates a new write-only instance of WTON, bound to a specific deployed contract. 13324 func NewWTONTransactor(address common.Address, transactor bind.ContractTransactor) (*WTONTransactor, error) { 13325 contract, err := bindWTON(address, nil, transactor, nil) 13326 if err != nil { 13327 return nil, err 13328 } 13329 return &WTONTransactor{contract: contract}, nil 13330 } 13331 13332 // NewWTONFilterer creates a new log filterer instance of WTON, bound to a specific deployed contract. 13333 func NewWTONFilterer(address common.Address, filterer bind.ContractFilterer) (*WTONFilterer, error) { 13334 contract, err := bindWTON(address, nil, nil, filterer) 13335 if err != nil { 13336 return nil, err 13337 } 13338 return &WTONFilterer{contract: contract}, nil 13339 } 13340 13341 // bindWTON binds a generic wrapper to an already deployed contract. 13342 func bindWTON(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 13343 parsed, err := abi.JSON(strings.NewReader(WTONABI)) 13344 if err != nil { 13345 return nil, err 13346 } 13347 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 13348 } 13349 13350 // Call invokes the (constant) contract method with params as input values and 13351 // sets the output to result. The result type might be a single field for simple 13352 // returns, a slice of interfaces for anonymous returns and a struct for named 13353 // returns. 13354 func (_WTON *WTONRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 13355 return _WTON.Contract.WTONCaller.contract.Call(opts, result, method, params...) 13356 } 13357 13358 // Transfer initiates a plain transaction to move funds to the contract, calling 13359 // its default method if one is available. 13360 func (_WTON *WTONRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 13361 return _WTON.Contract.WTONTransactor.contract.Transfer(opts) 13362 } 13363 13364 // Transact invokes the (paid) contract method with params as input values. 13365 func (_WTON *WTONRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 13366 return _WTON.Contract.WTONTransactor.contract.Transact(opts, method, params...) 13367 } 13368 13369 // Call invokes the (constant) contract method with params as input values and 13370 // sets the output to result. The result type might be a single field for simple 13371 // returns, a slice of interfaces for anonymous returns and a struct for named 13372 // returns. 13373 func (_WTON *WTONCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 13374 return _WTON.Contract.contract.Call(opts, result, method, params...) 13375 } 13376 13377 // Transfer initiates a plain transaction to move funds to the contract, calling 13378 // its default method if one is available. 13379 func (_WTON *WTONTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 13380 return _WTON.Contract.contract.Transfer(opts) 13381 } 13382 13383 // Transact invokes the (paid) contract method with params as input values. 13384 func (_WTON *WTONTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 13385 return _WTON.Contract.contract.Transact(opts, method, params...) 13386 } 13387 13388 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 13389 // 13390 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 13391 func (_WTON *WTONCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) { 13392 var ( 13393 ret0 = new([4]byte) 13394 ) 13395 out := ret0 13396 err := _WTON.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE") 13397 return *ret0, err 13398 } 13399 13400 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 13401 // 13402 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 13403 func (_WTON *WTONSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 13404 return _WTON.Contract.INTERFACEIDONAPPROVE(&_WTON.CallOpts) 13405 } 13406 13407 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 13408 // 13409 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 13410 func (_WTON *WTONCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 13411 return _WTON.Contract.INTERFACEIDONAPPROVE(&_WTON.CallOpts) 13412 } 13413 13414 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 13415 // 13416 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 13417 func (_WTON *WTONCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 13418 var ( 13419 ret0 = new(*big.Int) 13420 ) 13421 out := ret0 13422 err := _WTON.contract.Call(opts, out, "allowance", owner, spender) 13423 return *ret0, err 13424 } 13425 13426 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 13427 // 13428 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 13429 func (_WTON *WTONSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 13430 return _WTON.Contract.Allowance(&_WTON.CallOpts, owner, spender) 13431 } 13432 13433 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 13434 // 13435 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 13436 func (_WTON *WTONCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 13437 return _WTON.Contract.Allowance(&_WTON.CallOpts, owner, spender) 13438 } 13439 13440 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 13441 // 13442 // Solidity: function balanceOf(address account) constant returns(uint256) 13443 func (_WTON *WTONCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 13444 var ( 13445 ret0 = new(*big.Int) 13446 ) 13447 out := ret0 13448 err := _WTON.contract.Call(opts, out, "balanceOf", account) 13449 return *ret0, err 13450 } 13451 13452 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 13453 // 13454 // Solidity: function balanceOf(address account) constant returns(uint256) 13455 func (_WTON *WTONSession) BalanceOf(account common.Address) (*big.Int, error) { 13456 return _WTON.Contract.BalanceOf(&_WTON.CallOpts, account) 13457 } 13458 13459 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 13460 // 13461 // Solidity: function balanceOf(address account) constant returns(uint256) 13462 func (_WTON *WTONCallerSession) BalanceOf(account common.Address) (*big.Int, error) { 13463 return _WTON.Contract.BalanceOf(&_WTON.CallOpts, account) 13464 } 13465 13466 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 13467 // 13468 // Solidity: function decimals() constant returns(uint8) 13469 func (_WTON *WTONCaller) Decimals(opts *bind.CallOpts) (uint8, error) { 13470 var ( 13471 ret0 = new(uint8) 13472 ) 13473 out := ret0 13474 err := _WTON.contract.Call(opts, out, "decimals") 13475 return *ret0, err 13476 } 13477 13478 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 13479 // 13480 // Solidity: function decimals() constant returns(uint8) 13481 func (_WTON *WTONSession) Decimals() (uint8, error) { 13482 return _WTON.Contract.Decimals(&_WTON.CallOpts) 13483 } 13484 13485 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 13486 // 13487 // Solidity: function decimals() constant returns(uint8) 13488 func (_WTON *WTONCallerSession) Decimals() (uint8, error) { 13489 return _WTON.Contract.Decimals(&_WTON.CallOpts) 13490 } 13491 13492 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 13493 // 13494 // Solidity: function isMinter(address account) constant returns(bool) 13495 func (_WTON *WTONCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) { 13496 var ( 13497 ret0 = new(bool) 13498 ) 13499 out := ret0 13500 err := _WTON.contract.Call(opts, out, "isMinter", account) 13501 return *ret0, err 13502 } 13503 13504 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 13505 // 13506 // Solidity: function isMinter(address account) constant returns(bool) 13507 func (_WTON *WTONSession) IsMinter(account common.Address) (bool, error) { 13508 return _WTON.Contract.IsMinter(&_WTON.CallOpts, account) 13509 } 13510 13511 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 13512 // 13513 // Solidity: function isMinter(address account) constant returns(bool) 13514 func (_WTON *WTONCallerSession) IsMinter(account common.Address) (bool, error) { 13515 return _WTON.Contract.IsMinter(&_WTON.CallOpts, account) 13516 } 13517 13518 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 13519 // 13520 // Solidity: function isOwner() constant returns(bool) 13521 func (_WTON *WTONCaller) IsOwner(opts *bind.CallOpts) (bool, error) { 13522 var ( 13523 ret0 = new(bool) 13524 ) 13525 out := ret0 13526 err := _WTON.contract.Call(opts, out, "isOwner") 13527 return *ret0, err 13528 } 13529 13530 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 13531 // 13532 // Solidity: function isOwner() constant returns(bool) 13533 func (_WTON *WTONSession) IsOwner() (bool, error) { 13534 return _WTON.Contract.IsOwner(&_WTON.CallOpts) 13535 } 13536 13537 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 13538 // 13539 // Solidity: function isOwner() constant returns(bool) 13540 func (_WTON *WTONCallerSession) IsOwner() (bool, error) { 13541 return _WTON.Contract.IsOwner(&_WTON.CallOpts) 13542 } 13543 13544 // Name is a free data retrieval call binding the contract method 0x06fdde03. 13545 // 13546 // Solidity: function name() constant returns(string) 13547 func (_WTON *WTONCaller) Name(opts *bind.CallOpts) (string, error) { 13548 var ( 13549 ret0 = new(string) 13550 ) 13551 out := ret0 13552 err := _WTON.contract.Call(opts, out, "name") 13553 return *ret0, err 13554 } 13555 13556 // Name is a free data retrieval call binding the contract method 0x06fdde03. 13557 // 13558 // Solidity: function name() constant returns(string) 13559 func (_WTON *WTONSession) Name() (string, error) { 13560 return _WTON.Contract.Name(&_WTON.CallOpts) 13561 } 13562 13563 // Name is a free data retrieval call binding the contract method 0x06fdde03. 13564 // 13565 // Solidity: function name() constant returns(string) 13566 func (_WTON *WTONCallerSession) Name() (string, error) { 13567 return _WTON.Contract.Name(&_WTON.CallOpts) 13568 } 13569 13570 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 13571 // 13572 // Solidity: function owner() constant returns(address) 13573 func (_WTON *WTONCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 13574 var ( 13575 ret0 = new(common.Address) 13576 ) 13577 out := ret0 13578 err := _WTON.contract.Call(opts, out, "owner") 13579 return *ret0, err 13580 } 13581 13582 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 13583 // 13584 // Solidity: function owner() constant returns(address) 13585 func (_WTON *WTONSession) Owner() (common.Address, error) { 13586 return _WTON.Contract.Owner(&_WTON.CallOpts) 13587 } 13588 13589 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 13590 // 13591 // Solidity: function owner() constant returns(address) 13592 func (_WTON *WTONCallerSession) Owner() (common.Address, error) { 13593 return _WTON.Contract.Owner(&_WTON.CallOpts) 13594 } 13595 13596 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 13597 // 13598 // Solidity: function seigManager() constant returns(address) 13599 func (_WTON *WTONCaller) SeigManager(opts *bind.CallOpts) (common.Address, error) { 13600 var ( 13601 ret0 = new(common.Address) 13602 ) 13603 out := ret0 13604 err := _WTON.contract.Call(opts, out, "seigManager") 13605 return *ret0, err 13606 } 13607 13608 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 13609 // 13610 // Solidity: function seigManager() constant returns(address) 13611 func (_WTON *WTONSession) SeigManager() (common.Address, error) { 13612 return _WTON.Contract.SeigManager(&_WTON.CallOpts) 13613 } 13614 13615 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 13616 // 13617 // Solidity: function seigManager() constant returns(address) 13618 func (_WTON *WTONCallerSession) SeigManager() (common.Address, error) { 13619 return _WTON.Contract.SeigManager(&_WTON.CallOpts) 13620 } 13621 13622 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 13623 // 13624 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 13625 func (_WTON *WTONCaller) SupportsInterface(opts *bind.CallOpts, interfaceId [4]byte) (bool, error) { 13626 var ( 13627 ret0 = new(bool) 13628 ) 13629 out := ret0 13630 err := _WTON.contract.Call(opts, out, "supportsInterface", interfaceId) 13631 return *ret0, err 13632 } 13633 13634 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 13635 // 13636 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 13637 func (_WTON *WTONSession) SupportsInterface(interfaceId [4]byte) (bool, error) { 13638 return _WTON.Contract.SupportsInterface(&_WTON.CallOpts, interfaceId) 13639 } 13640 13641 // SupportsInterface is a free data retrieval call binding the contract method 0x01ffc9a7. 13642 // 13643 // Solidity: function supportsInterface(bytes4 interfaceId) constant returns(bool) 13644 func (_WTON *WTONCallerSession) SupportsInterface(interfaceId [4]byte) (bool, error) { 13645 return _WTON.Contract.SupportsInterface(&_WTON.CallOpts, interfaceId) 13646 } 13647 13648 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 13649 // 13650 // Solidity: function symbol() constant returns(string) 13651 func (_WTON *WTONCaller) Symbol(opts *bind.CallOpts) (string, error) { 13652 var ( 13653 ret0 = new(string) 13654 ) 13655 out := ret0 13656 err := _WTON.contract.Call(opts, out, "symbol") 13657 return *ret0, err 13658 } 13659 13660 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 13661 // 13662 // Solidity: function symbol() constant returns(string) 13663 func (_WTON *WTONSession) Symbol() (string, error) { 13664 return _WTON.Contract.Symbol(&_WTON.CallOpts) 13665 } 13666 13667 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 13668 // 13669 // Solidity: function symbol() constant returns(string) 13670 func (_WTON *WTONCallerSession) Symbol() (string, error) { 13671 return _WTON.Contract.Symbol(&_WTON.CallOpts) 13672 } 13673 13674 // Ton is a free data retrieval call binding the contract method 0xcc48b947. 13675 // 13676 // Solidity: function ton() constant returns(address) 13677 func (_WTON *WTONCaller) Ton(opts *bind.CallOpts) (common.Address, error) { 13678 var ( 13679 ret0 = new(common.Address) 13680 ) 13681 out := ret0 13682 err := _WTON.contract.Call(opts, out, "ton") 13683 return *ret0, err 13684 } 13685 13686 // Ton is a free data retrieval call binding the contract method 0xcc48b947. 13687 // 13688 // Solidity: function ton() constant returns(address) 13689 func (_WTON *WTONSession) Ton() (common.Address, error) { 13690 return _WTON.Contract.Ton(&_WTON.CallOpts) 13691 } 13692 13693 // Ton is a free data retrieval call binding the contract method 0xcc48b947. 13694 // 13695 // Solidity: function ton() constant returns(address) 13696 func (_WTON *WTONCallerSession) Ton() (common.Address, error) { 13697 return _WTON.Contract.Ton(&_WTON.CallOpts) 13698 } 13699 13700 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 13701 // 13702 // Solidity: function totalSupply() constant returns(uint256) 13703 func (_WTON *WTONCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 13704 var ( 13705 ret0 = new(*big.Int) 13706 ) 13707 out := ret0 13708 err := _WTON.contract.Call(opts, out, "totalSupply") 13709 return *ret0, err 13710 } 13711 13712 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 13713 // 13714 // Solidity: function totalSupply() constant returns(uint256) 13715 func (_WTON *WTONSession) TotalSupply() (*big.Int, error) { 13716 return _WTON.Contract.TotalSupply(&_WTON.CallOpts) 13717 } 13718 13719 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 13720 // 13721 // Solidity: function totalSupply() constant returns(uint256) 13722 func (_WTON *WTONCallerSession) TotalSupply() (*big.Int, error) { 13723 return _WTON.Contract.TotalSupply(&_WTON.CallOpts) 13724 } 13725 13726 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 13727 // 13728 // Solidity: function addMinter(address account) returns() 13729 func (_WTON *WTONTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) { 13730 return _WTON.contract.Transact(opts, "addMinter", account) 13731 } 13732 13733 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 13734 // 13735 // Solidity: function addMinter(address account) returns() 13736 func (_WTON *WTONSession) AddMinter(account common.Address) (*types.Transaction, error) { 13737 return _WTON.Contract.AddMinter(&_WTON.TransactOpts, account) 13738 } 13739 13740 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 13741 // 13742 // Solidity: function addMinter(address account) returns() 13743 func (_WTON *WTONTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) { 13744 return _WTON.Contract.AddMinter(&_WTON.TransactOpts, account) 13745 } 13746 13747 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 13748 // 13749 // Solidity: function approve(address spender, uint256 amount) returns(bool) 13750 func (_WTON *WTONTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 13751 return _WTON.contract.Transact(opts, "approve", spender, amount) 13752 } 13753 13754 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 13755 // 13756 // Solidity: function approve(address spender, uint256 amount) returns(bool) 13757 func (_WTON *WTONSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 13758 return _WTON.Contract.Approve(&_WTON.TransactOpts, spender, amount) 13759 } 13760 13761 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 13762 // 13763 // Solidity: function approve(address spender, uint256 amount) returns(bool) 13764 func (_WTON *WTONTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 13765 return _WTON.Contract.Approve(&_WTON.TransactOpts, spender, amount) 13766 } 13767 13768 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 13769 // 13770 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 13771 func (_WTON *WTONTransactor) ApproveAndCall(opts *bind.TransactOpts, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 13772 return _WTON.contract.Transact(opts, "approveAndCall", spender, amount, data) 13773 } 13774 13775 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 13776 // 13777 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 13778 func (_WTON *WTONSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 13779 return _WTON.Contract.ApproveAndCall(&_WTON.TransactOpts, spender, amount, data) 13780 } 13781 13782 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 13783 // 13784 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 13785 func (_WTON *WTONTransactorSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 13786 return _WTON.Contract.ApproveAndCall(&_WTON.TransactOpts, spender, amount, data) 13787 } 13788 13789 // Burn is a paid mutator transaction binding the contract method 0x42966c68. 13790 // 13791 // Solidity: function burn(uint256 amount) returns() 13792 func (_WTON *WTONTransactor) Burn(opts *bind.TransactOpts, amount *big.Int) (*types.Transaction, error) { 13793 return _WTON.contract.Transact(opts, "burn", amount) 13794 } 13795 13796 // Burn is a paid mutator transaction binding the contract method 0x42966c68. 13797 // 13798 // Solidity: function burn(uint256 amount) returns() 13799 func (_WTON *WTONSession) Burn(amount *big.Int) (*types.Transaction, error) { 13800 return _WTON.Contract.Burn(&_WTON.TransactOpts, amount) 13801 } 13802 13803 // Burn is a paid mutator transaction binding the contract method 0x42966c68. 13804 // 13805 // Solidity: function burn(uint256 amount) returns() 13806 func (_WTON *WTONTransactorSession) Burn(amount *big.Int) (*types.Transaction, error) { 13807 return _WTON.Contract.Burn(&_WTON.TransactOpts, amount) 13808 } 13809 13810 // BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790. 13811 // 13812 // Solidity: function burnFrom(address account, uint256 amount) returns() 13813 func (_WTON *WTONTransactor) BurnFrom(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { 13814 return _WTON.contract.Transact(opts, "burnFrom", account, amount) 13815 } 13816 13817 // BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790. 13818 // 13819 // Solidity: function burnFrom(address account, uint256 amount) returns() 13820 func (_WTON *WTONSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) { 13821 return _WTON.Contract.BurnFrom(&_WTON.TransactOpts, account, amount) 13822 } 13823 13824 // BurnFrom is a paid mutator transaction binding the contract method 0x79cc6790. 13825 // 13826 // Solidity: function burnFrom(address account, uint256 amount) returns() 13827 func (_WTON *WTONTransactorSession) BurnFrom(account common.Address, amount *big.Int) (*types.Transaction, error) { 13828 return _WTON.Contract.BurnFrom(&_WTON.TransactOpts, account, amount) 13829 } 13830 13831 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 13832 // 13833 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 13834 func (_WTON *WTONTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 13835 return _WTON.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) 13836 } 13837 13838 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 13839 // 13840 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 13841 func (_WTON *WTONSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 13842 return _WTON.Contract.DecreaseAllowance(&_WTON.TransactOpts, spender, subtractedValue) 13843 } 13844 13845 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 13846 // 13847 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 13848 func (_WTON *WTONTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 13849 return _WTON.Contract.DecreaseAllowance(&_WTON.TransactOpts, spender, subtractedValue) 13850 } 13851 13852 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 13853 // 13854 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 13855 func (_WTON *WTONTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 13856 return _WTON.contract.Transact(opts, "increaseAllowance", spender, addedValue) 13857 } 13858 13859 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 13860 // 13861 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 13862 func (_WTON *WTONSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 13863 return _WTON.Contract.IncreaseAllowance(&_WTON.TransactOpts, spender, addedValue) 13864 } 13865 13866 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 13867 // 13868 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 13869 func (_WTON *WTONTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 13870 return _WTON.Contract.IncreaseAllowance(&_WTON.TransactOpts, spender, addedValue) 13871 } 13872 13873 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 13874 // 13875 // Solidity: function mint(address account, uint256 amount) returns(bool) 13876 func (_WTON *WTONTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { 13877 return _WTON.contract.Transact(opts, "mint", account, amount) 13878 } 13879 13880 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 13881 // 13882 // Solidity: function mint(address account, uint256 amount) returns(bool) 13883 func (_WTON *WTONSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { 13884 return _WTON.Contract.Mint(&_WTON.TransactOpts, account, amount) 13885 } 13886 13887 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 13888 // 13889 // Solidity: function mint(address account, uint256 amount) returns(bool) 13890 func (_WTON *WTONTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { 13891 return _WTON.Contract.Mint(&_WTON.TransactOpts, account, amount) 13892 } 13893 13894 // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16. 13895 // 13896 // Solidity: function onApprove(address owner, address spender, uint256 tonAmount, bytes data) returns(bool) 13897 func (_WTON *WTONTransactor) OnApprove(opts *bind.TransactOpts, owner common.Address, spender common.Address, tonAmount *big.Int, data []byte) (*types.Transaction, error) { 13898 return _WTON.contract.Transact(opts, "onApprove", owner, spender, tonAmount, data) 13899 } 13900 13901 // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16. 13902 // 13903 // Solidity: function onApprove(address owner, address spender, uint256 tonAmount, bytes data) returns(bool) 13904 func (_WTON *WTONSession) OnApprove(owner common.Address, spender common.Address, tonAmount *big.Int, data []byte) (*types.Transaction, error) { 13905 return _WTON.Contract.OnApprove(&_WTON.TransactOpts, owner, spender, tonAmount, data) 13906 } 13907 13908 // OnApprove is a paid mutator transaction binding the contract method 0x4273ca16. 13909 // 13910 // Solidity: function onApprove(address owner, address spender, uint256 tonAmount, bytes data) returns(bool) 13911 func (_WTON *WTONTransactorSession) OnApprove(owner common.Address, spender common.Address, tonAmount *big.Int, data []byte) (*types.Transaction, error) { 13912 return _WTON.Contract.OnApprove(&_WTON.TransactOpts, owner, spender, tonAmount, data) 13913 } 13914 13915 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 13916 // 13917 // Solidity: function renounceMinter(address target) returns() 13918 func (_WTON *WTONTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 13919 return _WTON.contract.Transact(opts, "renounceMinter", target) 13920 } 13921 13922 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 13923 // 13924 // Solidity: function renounceMinter(address target) returns() 13925 func (_WTON *WTONSession) RenounceMinter(target common.Address) (*types.Transaction, error) { 13926 return _WTON.Contract.RenounceMinter(&_WTON.TransactOpts, target) 13927 } 13928 13929 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 13930 // 13931 // Solidity: function renounceMinter(address target) returns() 13932 func (_WTON *WTONTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) { 13933 return _WTON.Contract.RenounceMinter(&_WTON.TransactOpts, target) 13934 } 13935 13936 // RenounceMinter0 is a paid mutator transaction binding the contract method 0x98650275. 13937 // 13938 // Solidity: function renounceMinter() returns() 13939 func (_WTON *WTONTransactor) RenounceMinter0(opts *bind.TransactOpts) (*types.Transaction, error) { 13940 return _WTON.contract.Transact(opts, "renounceMinter0") 13941 } 13942 13943 // RenounceMinter0 is a paid mutator transaction binding the contract method 0x98650275. 13944 // 13945 // Solidity: function renounceMinter() returns() 13946 func (_WTON *WTONSession) RenounceMinter0() (*types.Transaction, error) { 13947 return _WTON.Contract.RenounceMinter0(&_WTON.TransactOpts) 13948 } 13949 13950 // RenounceMinter0 is a paid mutator transaction binding the contract method 0x98650275. 13951 // 13952 // Solidity: function renounceMinter() returns() 13953 func (_WTON *WTONTransactorSession) RenounceMinter0() (*types.Transaction, error) { 13954 return _WTON.Contract.RenounceMinter0(&_WTON.TransactOpts) 13955 } 13956 13957 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 13958 // 13959 // Solidity: function renounceOwnership(address target) returns() 13960 func (_WTON *WTONTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 13961 return _WTON.contract.Transact(opts, "renounceOwnership", target) 13962 } 13963 13964 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 13965 // 13966 // Solidity: function renounceOwnership(address target) returns() 13967 func (_WTON *WTONSession) RenounceOwnership(target common.Address) (*types.Transaction, error) { 13968 return _WTON.Contract.RenounceOwnership(&_WTON.TransactOpts, target) 13969 } 13970 13971 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 13972 // 13973 // Solidity: function renounceOwnership(address target) returns() 13974 func (_WTON *WTONTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) { 13975 return _WTON.Contract.RenounceOwnership(&_WTON.TransactOpts, target) 13976 } 13977 13978 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 13979 // 13980 // Solidity: function renounceOwnership() returns() 13981 func (_WTON *WTONTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) { 13982 return _WTON.contract.Transact(opts, "renounceOwnership0") 13983 } 13984 13985 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 13986 // 13987 // Solidity: function renounceOwnership() returns() 13988 func (_WTON *WTONSession) RenounceOwnership0() (*types.Transaction, error) { 13989 return _WTON.Contract.RenounceOwnership0(&_WTON.TransactOpts) 13990 } 13991 13992 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 13993 // 13994 // Solidity: function renounceOwnership() returns() 13995 func (_WTON *WTONTransactorSession) RenounceOwnership0() (*types.Transaction, error) { 13996 return _WTON.Contract.RenounceOwnership0(&_WTON.TransactOpts) 13997 } 13998 13999 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 14000 // 14001 // Solidity: function renouncePauser(address target) returns() 14002 func (_WTON *WTONTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 14003 return _WTON.contract.Transact(opts, "renouncePauser", target) 14004 } 14005 14006 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 14007 // 14008 // Solidity: function renouncePauser(address target) returns() 14009 func (_WTON *WTONSession) RenouncePauser(target common.Address) (*types.Transaction, error) { 14010 return _WTON.Contract.RenouncePauser(&_WTON.TransactOpts, target) 14011 } 14012 14013 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 14014 // 14015 // Solidity: function renouncePauser(address target) returns() 14016 func (_WTON *WTONTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) { 14017 return _WTON.Contract.RenouncePauser(&_WTON.TransactOpts, target) 14018 } 14019 14020 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 14021 // 14022 // Solidity: function setSeigManager(address _seigManager) returns() 14023 func (_WTON *WTONTransactor) SetSeigManager(opts *bind.TransactOpts, _seigManager common.Address) (*types.Transaction, error) { 14024 return _WTON.contract.Transact(opts, "setSeigManager", _seigManager) 14025 } 14026 14027 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 14028 // 14029 // Solidity: function setSeigManager(address _seigManager) returns() 14030 func (_WTON *WTONSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) { 14031 return _WTON.Contract.SetSeigManager(&_WTON.TransactOpts, _seigManager) 14032 } 14033 14034 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 14035 // 14036 // Solidity: function setSeigManager(address _seigManager) returns() 14037 func (_WTON *WTONTransactorSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) { 14038 return _WTON.Contract.SetSeigManager(&_WTON.TransactOpts, _seigManager) 14039 } 14040 14041 // SwapFromTON is a paid mutator transaction binding the contract method 0xe34869d7. 14042 // 14043 // Solidity: function swapFromTON(uint256 tonAmount) returns(bool) 14044 func (_WTON *WTONTransactor) SwapFromTON(opts *bind.TransactOpts, tonAmount *big.Int) (*types.Transaction, error) { 14045 return _WTON.contract.Transact(opts, "swapFromTON", tonAmount) 14046 } 14047 14048 // SwapFromTON is a paid mutator transaction binding the contract method 0xe34869d7. 14049 // 14050 // Solidity: function swapFromTON(uint256 tonAmount) returns(bool) 14051 func (_WTON *WTONSession) SwapFromTON(tonAmount *big.Int) (*types.Transaction, error) { 14052 return _WTON.Contract.SwapFromTON(&_WTON.TransactOpts, tonAmount) 14053 } 14054 14055 // SwapFromTON is a paid mutator transaction binding the contract method 0xe34869d7. 14056 // 14057 // Solidity: function swapFromTON(uint256 tonAmount) returns(bool) 14058 func (_WTON *WTONTransactorSession) SwapFromTON(tonAmount *big.Int) (*types.Transaction, error) { 14059 return _WTON.Contract.SwapFromTON(&_WTON.TransactOpts, tonAmount) 14060 } 14061 14062 // SwapFromTONAndTransfer is a paid mutator transaction binding the contract method 0x588420b7. 14063 // 14064 // Solidity: function swapFromTONAndTransfer(address to, uint256 tonAmount) returns(bool) 14065 func (_WTON *WTONTransactor) SwapFromTONAndTransfer(opts *bind.TransactOpts, to common.Address, tonAmount *big.Int) (*types.Transaction, error) { 14066 return _WTON.contract.Transact(opts, "swapFromTONAndTransfer", to, tonAmount) 14067 } 14068 14069 // SwapFromTONAndTransfer is a paid mutator transaction binding the contract method 0x588420b7. 14070 // 14071 // Solidity: function swapFromTONAndTransfer(address to, uint256 tonAmount) returns(bool) 14072 func (_WTON *WTONSession) SwapFromTONAndTransfer(to common.Address, tonAmount *big.Int) (*types.Transaction, error) { 14073 return _WTON.Contract.SwapFromTONAndTransfer(&_WTON.TransactOpts, to, tonAmount) 14074 } 14075 14076 // SwapFromTONAndTransfer is a paid mutator transaction binding the contract method 0x588420b7. 14077 // 14078 // Solidity: function swapFromTONAndTransfer(address to, uint256 tonAmount) returns(bool) 14079 func (_WTON *WTONTransactorSession) SwapFromTONAndTransfer(to common.Address, tonAmount *big.Int) (*types.Transaction, error) { 14080 return _WTON.Contract.SwapFromTONAndTransfer(&_WTON.TransactOpts, to, tonAmount) 14081 } 14082 14083 // SwapToTON is a paid mutator transaction binding the contract method 0xf53fe70f. 14084 // 14085 // Solidity: function swapToTON(uint256 wtonAmount) returns(bool) 14086 func (_WTON *WTONTransactor) SwapToTON(opts *bind.TransactOpts, wtonAmount *big.Int) (*types.Transaction, error) { 14087 return _WTON.contract.Transact(opts, "swapToTON", wtonAmount) 14088 } 14089 14090 // SwapToTON is a paid mutator transaction binding the contract method 0xf53fe70f. 14091 // 14092 // Solidity: function swapToTON(uint256 wtonAmount) returns(bool) 14093 func (_WTON *WTONSession) SwapToTON(wtonAmount *big.Int) (*types.Transaction, error) { 14094 return _WTON.Contract.SwapToTON(&_WTON.TransactOpts, wtonAmount) 14095 } 14096 14097 // SwapToTON is a paid mutator transaction binding the contract method 0xf53fe70f. 14098 // 14099 // Solidity: function swapToTON(uint256 wtonAmount) returns(bool) 14100 func (_WTON *WTONTransactorSession) SwapToTON(wtonAmount *big.Int) (*types.Transaction, error) { 14101 return _WTON.Contract.SwapToTON(&_WTON.TransactOpts, wtonAmount) 14102 } 14103 14104 // SwapToTONAndTransfer is a paid mutator transaction binding the contract method 0xe3b99e85. 14105 // 14106 // Solidity: function swapToTONAndTransfer(address to, uint256 wtonAmount) returns(bool) 14107 func (_WTON *WTONTransactor) SwapToTONAndTransfer(opts *bind.TransactOpts, to common.Address, wtonAmount *big.Int) (*types.Transaction, error) { 14108 return _WTON.contract.Transact(opts, "swapToTONAndTransfer", to, wtonAmount) 14109 } 14110 14111 // SwapToTONAndTransfer is a paid mutator transaction binding the contract method 0xe3b99e85. 14112 // 14113 // Solidity: function swapToTONAndTransfer(address to, uint256 wtonAmount) returns(bool) 14114 func (_WTON *WTONSession) SwapToTONAndTransfer(to common.Address, wtonAmount *big.Int) (*types.Transaction, error) { 14115 return _WTON.Contract.SwapToTONAndTransfer(&_WTON.TransactOpts, to, wtonAmount) 14116 } 14117 14118 // SwapToTONAndTransfer is a paid mutator transaction binding the contract method 0xe3b99e85. 14119 // 14120 // Solidity: function swapToTONAndTransfer(address to, uint256 wtonAmount) returns(bool) 14121 func (_WTON *WTONTransactorSession) SwapToTONAndTransfer(to common.Address, wtonAmount *big.Int) (*types.Transaction, error) { 14122 return _WTON.Contract.SwapToTONAndTransfer(&_WTON.TransactOpts, to, wtonAmount) 14123 } 14124 14125 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 14126 // 14127 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 14128 func (_WTON *WTONTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 14129 return _WTON.contract.Transact(opts, "transfer", recipient, amount) 14130 } 14131 14132 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 14133 // 14134 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 14135 func (_WTON *WTONSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 14136 return _WTON.Contract.Transfer(&_WTON.TransactOpts, recipient, amount) 14137 } 14138 14139 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 14140 // 14141 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 14142 func (_WTON *WTONTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 14143 return _WTON.Contract.Transfer(&_WTON.TransactOpts, recipient, amount) 14144 } 14145 14146 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 14147 // 14148 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 14149 func (_WTON *WTONTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 14150 return _WTON.contract.Transact(opts, "transferFrom", sender, recipient, amount) 14151 } 14152 14153 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 14154 // 14155 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 14156 func (_WTON *WTONSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 14157 return _WTON.Contract.TransferFrom(&_WTON.TransactOpts, sender, recipient, amount) 14158 } 14159 14160 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 14161 // 14162 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 14163 func (_WTON *WTONTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 14164 return _WTON.Contract.TransferFrom(&_WTON.TransactOpts, sender, recipient, amount) 14165 } 14166 14167 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 14168 // 14169 // Solidity: function transferOwnership(address target, address newOwner) returns() 14170 func (_WTON *WTONTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) { 14171 return _WTON.contract.Transact(opts, "transferOwnership", target, newOwner) 14172 } 14173 14174 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 14175 // 14176 // Solidity: function transferOwnership(address target, address newOwner) returns() 14177 func (_WTON *WTONSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) { 14178 return _WTON.Contract.TransferOwnership(&_WTON.TransactOpts, target, newOwner) 14179 } 14180 14181 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 14182 // 14183 // Solidity: function transferOwnership(address target, address newOwner) returns() 14184 func (_WTON *WTONTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) { 14185 return _WTON.Contract.TransferOwnership(&_WTON.TransactOpts, target, newOwner) 14186 } 14187 14188 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 14189 // 14190 // Solidity: function transferOwnership(address newOwner) returns() 14191 func (_WTON *WTONTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 14192 return _WTON.contract.Transact(opts, "transferOwnership0", newOwner) 14193 } 14194 14195 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 14196 // 14197 // Solidity: function transferOwnership(address newOwner) returns() 14198 func (_WTON *WTONSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) { 14199 return _WTON.Contract.TransferOwnership0(&_WTON.TransactOpts, newOwner) 14200 } 14201 14202 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 14203 // 14204 // Solidity: function transferOwnership(address newOwner) returns() 14205 func (_WTON *WTONTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) { 14206 return _WTON.Contract.TransferOwnership0(&_WTON.TransactOpts, newOwner) 14207 } 14208 14209 // WTONApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the WTON contract. 14210 type WTONApprovalIterator struct { 14211 Event *WTONApproval // Event containing the contract specifics and raw log 14212 14213 contract *bind.BoundContract // Generic contract to use for unpacking event data 14214 event string // Event name to use for unpacking event data 14215 14216 logs chan types.Log // Log channel receiving the found contract events 14217 sub ethereum.Subscription // Subscription for errors, completion and termination 14218 done bool // Whether the subscription completed delivering logs 14219 fail error // Occurred error to stop iteration 14220 } 14221 14222 // Next advances the iterator to the subsequent event, returning whether there 14223 // are any more events found. In case of a retrieval or parsing error, false is 14224 // returned and Error() can be queried for the exact failure. 14225 func (it *WTONApprovalIterator) Next() bool { 14226 // If the iterator failed, stop iterating 14227 if it.fail != nil { 14228 return false 14229 } 14230 // If the iterator completed, deliver directly whatever's available 14231 if it.done { 14232 select { 14233 case log := <-it.logs: 14234 it.Event = new(WTONApproval) 14235 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 14236 it.fail = err 14237 return false 14238 } 14239 it.Event.Raw = log 14240 return true 14241 14242 default: 14243 return false 14244 } 14245 } 14246 // Iterator still in progress, wait for either a data or an error event 14247 select { 14248 case log := <-it.logs: 14249 it.Event = new(WTONApproval) 14250 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 14251 it.fail = err 14252 return false 14253 } 14254 it.Event.Raw = log 14255 return true 14256 14257 case err := <-it.sub.Err(): 14258 it.done = true 14259 it.fail = err 14260 return it.Next() 14261 } 14262 } 14263 14264 // Error returns any retrieval or parsing error occurred during filtering. 14265 func (it *WTONApprovalIterator) Error() error { 14266 return it.fail 14267 } 14268 14269 // Close terminates the iteration process, releasing any pending underlying 14270 // resources. 14271 func (it *WTONApprovalIterator) Close() error { 14272 it.sub.Unsubscribe() 14273 return nil 14274 } 14275 14276 // WTONApproval represents a Approval event raised by the WTON contract. 14277 type WTONApproval struct { 14278 Owner common.Address 14279 Spender common.Address 14280 Value *big.Int 14281 Raw types.Log // Blockchain specific contextual infos 14282 } 14283 14284 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 14285 // 14286 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 14287 func (_WTON *WTONFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*WTONApprovalIterator, error) { 14288 14289 var ownerRule []interface{} 14290 for _, ownerItem := range owner { 14291 ownerRule = append(ownerRule, ownerItem) 14292 } 14293 var spenderRule []interface{} 14294 for _, spenderItem := range spender { 14295 spenderRule = append(spenderRule, spenderItem) 14296 } 14297 14298 logs, sub, err := _WTON.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 14299 if err != nil { 14300 return nil, err 14301 } 14302 return &WTONApprovalIterator{contract: _WTON.contract, event: "Approval", logs: logs, sub: sub}, nil 14303 } 14304 14305 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 14306 // 14307 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 14308 func (_WTON *WTONFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *WTONApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 14309 14310 var ownerRule []interface{} 14311 for _, ownerItem := range owner { 14312 ownerRule = append(ownerRule, ownerItem) 14313 } 14314 var spenderRule []interface{} 14315 for _, spenderItem := range spender { 14316 spenderRule = append(spenderRule, spenderItem) 14317 } 14318 14319 logs, sub, err := _WTON.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 14320 if err != nil { 14321 return nil, err 14322 } 14323 return event.NewSubscription(func(quit <-chan struct{}) error { 14324 defer sub.Unsubscribe() 14325 for { 14326 select { 14327 case log := <-logs: 14328 // New log arrived, parse the event and forward to the user 14329 event := new(WTONApproval) 14330 if err := _WTON.contract.UnpackLog(event, "Approval", log); err != nil { 14331 return err 14332 } 14333 event.Raw = log 14334 14335 select { 14336 case sink <- event: 14337 case err := <-sub.Err(): 14338 return err 14339 case <-quit: 14340 return nil 14341 } 14342 case err := <-sub.Err(): 14343 return err 14344 case <-quit: 14345 return nil 14346 } 14347 } 14348 }), nil 14349 } 14350 14351 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 14352 // 14353 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 14354 func (_WTON *WTONFilterer) ParseApproval(log types.Log) (*WTONApproval, error) { 14355 event := new(WTONApproval) 14356 if err := _WTON.contract.UnpackLog(event, "Approval", log); err != nil { 14357 return nil, err 14358 } 14359 return event, nil 14360 } 14361 14362 // WTONMinterAddedIterator is returned from FilterMinterAdded and is used to iterate over the raw logs and unpacked data for MinterAdded events raised by the WTON contract. 14363 type WTONMinterAddedIterator struct { 14364 Event *WTONMinterAdded // Event containing the contract specifics and raw log 14365 14366 contract *bind.BoundContract // Generic contract to use for unpacking event data 14367 event string // Event name to use for unpacking event data 14368 14369 logs chan types.Log // Log channel receiving the found contract events 14370 sub ethereum.Subscription // Subscription for errors, completion and termination 14371 done bool // Whether the subscription completed delivering logs 14372 fail error // Occurred error to stop iteration 14373 } 14374 14375 // Next advances the iterator to the subsequent event, returning whether there 14376 // are any more events found. In case of a retrieval or parsing error, false is 14377 // returned and Error() can be queried for the exact failure. 14378 func (it *WTONMinterAddedIterator) Next() bool { 14379 // If the iterator failed, stop iterating 14380 if it.fail != nil { 14381 return false 14382 } 14383 // If the iterator completed, deliver directly whatever's available 14384 if it.done { 14385 select { 14386 case log := <-it.logs: 14387 it.Event = new(WTONMinterAdded) 14388 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 14389 it.fail = err 14390 return false 14391 } 14392 it.Event.Raw = log 14393 return true 14394 14395 default: 14396 return false 14397 } 14398 } 14399 // Iterator still in progress, wait for either a data or an error event 14400 select { 14401 case log := <-it.logs: 14402 it.Event = new(WTONMinterAdded) 14403 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 14404 it.fail = err 14405 return false 14406 } 14407 it.Event.Raw = log 14408 return true 14409 14410 case err := <-it.sub.Err(): 14411 it.done = true 14412 it.fail = err 14413 return it.Next() 14414 } 14415 } 14416 14417 // Error returns any retrieval or parsing error occurred during filtering. 14418 func (it *WTONMinterAddedIterator) Error() error { 14419 return it.fail 14420 } 14421 14422 // Close terminates the iteration process, releasing any pending underlying 14423 // resources. 14424 func (it *WTONMinterAddedIterator) Close() error { 14425 it.sub.Unsubscribe() 14426 return nil 14427 } 14428 14429 // WTONMinterAdded represents a MinterAdded event raised by the WTON contract. 14430 type WTONMinterAdded struct { 14431 Account common.Address 14432 Raw types.Log // Blockchain specific contextual infos 14433 } 14434 14435 // FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 14436 // 14437 // Solidity: event MinterAdded(address indexed account) 14438 func (_WTON *WTONFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*WTONMinterAddedIterator, error) { 14439 14440 var accountRule []interface{} 14441 for _, accountItem := range account { 14442 accountRule = append(accountRule, accountItem) 14443 } 14444 14445 logs, sub, err := _WTON.contract.FilterLogs(opts, "MinterAdded", accountRule) 14446 if err != nil { 14447 return nil, err 14448 } 14449 return &WTONMinterAddedIterator{contract: _WTON.contract, event: "MinterAdded", logs: logs, sub: sub}, nil 14450 } 14451 14452 // WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 14453 // 14454 // Solidity: event MinterAdded(address indexed account) 14455 func (_WTON *WTONFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *WTONMinterAdded, account []common.Address) (event.Subscription, error) { 14456 14457 var accountRule []interface{} 14458 for _, accountItem := range account { 14459 accountRule = append(accountRule, accountItem) 14460 } 14461 14462 logs, sub, err := _WTON.contract.WatchLogs(opts, "MinterAdded", accountRule) 14463 if err != nil { 14464 return nil, err 14465 } 14466 return event.NewSubscription(func(quit <-chan struct{}) error { 14467 defer sub.Unsubscribe() 14468 for { 14469 select { 14470 case log := <-logs: 14471 // New log arrived, parse the event and forward to the user 14472 event := new(WTONMinterAdded) 14473 if err := _WTON.contract.UnpackLog(event, "MinterAdded", log); err != nil { 14474 return err 14475 } 14476 event.Raw = log 14477 14478 select { 14479 case sink <- event: 14480 case err := <-sub.Err(): 14481 return err 14482 case <-quit: 14483 return nil 14484 } 14485 case err := <-sub.Err(): 14486 return err 14487 case <-quit: 14488 return nil 14489 } 14490 } 14491 }), nil 14492 } 14493 14494 // ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 14495 // 14496 // Solidity: event MinterAdded(address indexed account) 14497 func (_WTON *WTONFilterer) ParseMinterAdded(log types.Log) (*WTONMinterAdded, error) { 14498 event := new(WTONMinterAdded) 14499 if err := _WTON.contract.UnpackLog(event, "MinterAdded", log); err != nil { 14500 return nil, err 14501 } 14502 return event, nil 14503 } 14504 14505 // WTONMinterRemovedIterator is returned from FilterMinterRemoved and is used to iterate over the raw logs and unpacked data for MinterRemoved events raised by the WTON contract. 14506 type WTONMinterRemovedIterator struct { 14507 Event *WTONMinterRemoved // Event containing the contract specifics and raw log 14508 14509 contract *bind.BoundContract // Generic contract to use for unpacking event data 14510 event string // Event name to use for unpacking event data 14511 14512 logs chan types.Log // Log channel receiving the found contract events 14513 sub ethereum.Subscription // Subscription for errors, completion and termination 14514 done bool // Whether the subscription completed delivering logs 14515 fail error // Occurred error to stop iteration 14516 } 14517 14518 // Next advances the iterator to the subsequent event, returning whether there 14519 // are any more events found. In case of a retrieval or parsing error, false is 14520 // returned and Error() can be queried for the exact failure. 14521 func (it *WTONMinterRemovedIterator) Next() bool { 14522 // If the iterator failed, stop iterating 14523 if it.fail != nil { 14524 return false 14525 } 14526 // If the iterator completed, deliver directly whatever's available 14527 if it.done { 14528 select { 14529 case log := <-it.logs: 14530 it.Event = new(WTONMinterRemoved) 14531 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 14532 it.fail = err 14533 return false 14534 } 14535 it.Event.Raw = log 14536 return true 14537 14538 default: 14539 return false 14540 } 14541 } 14542 // Iterator still in progress, wait for either a data or an error event 14543 select { 14544 case log := <-it.logs: 14545 it.Event = new(WTONMinterRemoved) 14546 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 14547 it.fail = err 14548 return false 14549 } 14550 it.Event.Raw = log 14551 return true 14552 14553 case err := <-it.sub.Err(): 14554 it.done = true 14555 it.fail = err 14556 return it.Next() 14557 } 14558 } 14559 14560 // Error returns any retrieval or parsing error occurred during filtering. 14561 func (it *WTONMinterRemovedIterator) Error() error { 14562 return it.fail 14563 } 14564 14565 // Close terminates the iteration process, releasing any pending underlying 14566 // resources. 14567 func (it *WTONMinterRemovedIterator) Close() error { 14568 it.sub.Unsubscribe() 14569 return nil 14570 } 14571 14572 // WTONMinterRemoved represents a MinterRemoved event raised by the WTON contract. 14573 type WTONMinterRemoved struct { 14574 Account common.Address 14575 Raw types.Log // Blockchain specific contextual infos 14576 } 14577 14578 // FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 14579 // 14580 // Solidity: event MinterRemoved(address indexed account) 14581 func (_WTON *WTONFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*WTONMinterRemovedIterator, error) { 14582 14583 var accountRule []interface{} 14584 for _, accountItem := range account { 14585 accountRule = append(accountRule, accountItem) 14586 } 14587 14588 logs, sub, err := _WTON.contract.FilterLogs(opts, "MinterRemoved", accountRule) 14589 if err != nil { 14590 return nil, err 14591 } 14592 return &WTONMinterRemovedIterator{contract: _WTON.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil 14593 } 14594 14595 // WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 14596 // 14597 // Solidity: event MinterRemoved(address indexed account) 14598 func (_WTON *WTONFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *WTONMinterRemoved, account []common.Address) (event.Subscription, error) { 14599 14600 var accountRule []interface{} 14601 for _, accountItem := range account { 14602 accountRule = append(accountRule, accountItem) 14603 } 14604 14605 logs, sub, err := _WTON.contract.WatchLogs(opts, "MinterRemoved", accountRule) 14606 if err != nil { 14607 return nil, err 14608 } 14609 return event.NewSubscription(func(quit <-chan struct{}) error { 14610 defer sub.Unsubscribe() 14611 for { 14612 select { 14613 case log := <-logs: 14614 // New log arrived, parse the event and forward to the user 14615 event := new(WTONMinterRemoved) 14616 if err := _WTON.contract.UnpackLog(event, "MinterRemoved", log); err != nil { 14617 return err 14618 } 14619 event.Raw = log 14620 14621 select { 14622 case sink <- event: 14623 case err := <-sub.Err(): 14624 return err 14625 case <-quit: 14626 return nil 14627 } 14628 case err := <-sub.Err(): 14629 return err 14630 case <-quit: 14631 return nil 14632 } 14633 } 14634 }), nil 14635 } 14636 14637 // ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 14638 // 14639 // Solidity: event MinterRemoved(address indexed account) 14640 func (_WTON *WTONFilterer) ParseMinterRemoved(log types.Log) (*WTONMinterRemoved, error) { 14641 event := new(WTONMinterRemoved) 14642 if err := _WTON.contract.UnpackLog(event, "MinterRemoved", log); err != nil { 14643 return nil, err 14644 } 14645 return event, nil 14646 } 14647 14648 // WTONOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the WTON contract. 14649 type WTONOwnershipTransferredIterator struct { 14650 Event *WTONOwnershipTransferred // Event containing the contract specifics and raw log 14651 14652 contract *bind.BoundContract // Generic contract to use for unpacking event data 14653 event string // Event name to use for unpacking event data 14654 14655 logs chan types.Log // Log channel receiving the found contract events 14656 sub ethereum.Subscription // Subscription for errors, completion and termination 14657 done bool // Whether the subscription completed delivering logs 14658 fail error // Occurred error to stop iteration 14659 } 14660 14661 // Next advances the iterator to the subsequent event, returning whether there 14662 // are any more events found. In case of a retrieval or parsing error, false is 14663 // returned and Error() can be queried for the exact failure. 14664 func (it *WTONOwnershipTransferredIterator) Next() bool { 14665 // If the iterator failed, stop iterating 14666 if it.fail != nil { 14667 return false 14668 } 14669 // If the iterator completed, deliver directly whatever's available 14670 if it.done { 14671 select { 14672 case log := <-it.logs: 14673 it.Event = new(WTONOwnershipTransferred) 14674 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 14675 it.fail = err 14676 return false 14677 } 14678 it.Event.Raw = log 14679 return true 14680 14681 default: 14682 return false 14683 } 14684 } 14685 // Iterator still in progress, wait for either a data or an error event 14686 select { 14687 case log := <-it.logs: 14688 it.Event = new(WTONOwnershipTransferred) 14689 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 14690 it.fail = err 14691 return false 14692 } 14693 it.Event.Raw = log 14694 return true 14695 14696 case err := <-it.sub.Err(): 14697 it.done = true 14698 it.fail = err 14699 return it.Next() 14700 } 14701 } 14702 14703 // Error returns any retrieval or parsing error occurred during filtering. 14704 func (it *WTONOwnershipTransferredIterator) Error() error { 14705 return it.fail 14706 } 14707 14708 // Close terminates the iteration process, releasing any pending underlying 14709 // resources. 14710 func (it *WTONOwnershipTransferredIterator) Close() error { 14711 it.sub.Unsubscribe() 14712 return nil 14713 } 14714 14715 // WTONOwnershipTransferred represents a OwnershipTransferred event raised by the WTON contract. 14716 type WTONOwnershipTransferred struct { 14717 PreviousOwner common.Address 14718 NewOwner common.Address 14719 Raw types.Log // Blockchain specific contextual infos 14720 } 14721 14722 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 14723 // 14724 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 14725 func (_WTON *WTONFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*WTONOwnershipTransferredIterator, error) { 14726 14727 var previousOwnerRule []interface{} 14728 for _, previousOwnerItem := range previousOwner { 14729 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 14730 } 14731 var newOwnerRule []interface{} 14732 for _, newOwnerItem := range newOwner { 14733 newOwnerRule = append(newOwnerRule, newOwnerItem) 14734 } 14735 14736 logs, sub, err := _WTON.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 14737 if err != nil { 14738 return nil, err 14739 } 14740 return &WTONOwnershipTransferredIterator{contract: _WTON.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 14741 } 14742 14743 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 14744 // 14745 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 14746 func (_WTON *WTONFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *WTONOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 14747 14748 var previousOwnerRule []interface{} 14749 for _, previousOwnerItem := range previousOwner { 14750 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 14751 } 14752 var newOwnerRule []interface{} 14753 for _, newOwnerItem := range newOwner { 14754 newOwnerRule = append(newOwnerRule, newOwnerItem) 14755 } 14756 14757 logs, sub, err := _WTON.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 14758 if err != nil { 14759 return nil, err 14760 } 14761 return event.NewSubscription(func(quit <-chan struct{}) error { 14762 defer sub.Unsubscribe() 14763 for { 14764 select { 14765 case log := <-logs: 14766 // New log arrived, parse the event and forward to the user 14767 event := new(WTONOwnershipTransferred) 14768 if err := _WTON.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 14769 return err 14770 } 14771 event.Raw = log 14772 14773 select { 14774 case sink <- event: 14775 case err := <-sub.Err(): 14776 return err 14777 case <-quit: 14778 return nil 14779 } 14780 case err := <-sub.Err(): 14781 return err 14782 case <-quit: 14783 return nil 14784 } 14785 } 14786 }), nil 14787 } 14788 14789 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 14790 // 14791 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 14792 func (_WTON *WTONFilterer) ParseOwnershipTransferred(log types.Log) (*WTONOwnershipTransferred, error) { 14793 event := new(WTONOwnershipTransferred) 14794 if err := _WTON.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 14795 return nil, err 14796 } 14797 return event, nil 14798 } 14799 14800 // WTONTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the WTON contract. 14801 type WTONTransferIterator struct { 14802 Event *WTONTransfer // Event containing the contract specifics and raw log 14803 14804 contract *bind.BoundContract // Generic contract to use for unpacking event data 14805 event string // Event name to use for unpacking event data 14806 14807 logs chan types.Log // Log channel receiving the found contract events 14808 sub ethereum.Subscription // Subscription for errors, completion and termination 14809 done bool // Whether the subscription completed delivering logs 14810 fail error // Occurred error to stop iteration 14811 } 14812 14813 // Next advances the iterator to the subsequent event, returning whether there 14814 // are any more events found. In case of a retrieval or parsing error, false is 14815 // returned and Error() can be queried for the exact failure. 14816 func (it *WTONTransferIterator) Next() bool { 14817 // If the iterator failed, stop iterating 14818 if it.fail != nil { 14819 return false 14820 } 14821 // If the iterator completed, deliver directly whatever's available 14822 if it.done { 14823 select { 14824 case log := <-it.logs: 14825 it.Event = new(WTONTransfer) 14826 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 14827 it.fail = err 14828 return false 14829 } 14830 it.Event.Raw = log 14831 return true 14832 14833 default: 14834 return false 14835 } 14836 } 14837 // Iterator still in progress, wait for either a data or an error event 14838 select { 14839 case log := <-it.logs: 14840 it.Event = new(WTONTransfer) 14841 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 14842 it.fail = err 14843 return false 14844 } 14845 it.Event.Raw = log 14846 return true 14847 14848 case err := <-it.sub.Err(): 14849 it.done = true 14850 it.fail = err 14851 return it.Next() 14852 } 14853 } 14854 14855 // Error returns any retrieval or parsing error occurred during filtering. 14856 func (it *WTONTransferIterator) Error() error { 14857 return it.fail 14858 } 14859 14860 // Close terminates the iteration process, releasing any pending underlying 14861 // resources. 14862 func (it *WTONTransferIterator) Close() error { 14863 it.sub.Unsubscribe() 14864 return nil 14865 } 14866 14867 // WTONTransfer represents a Transfer event raised by the WTON contract. 14868 type WTONTransfer struct { 14869 From common.Address 14870 To common.Address 14871 Value *big.Int 14872 Raw types.Log // Blockchain specific contextual infos 14873 } 14874 14875 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 14876 // 14877 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 14878 func (_WTON *WTONFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*WTONTransferIterator, error) { 14879 14880 var fromRule []interface{} 14881 for _, fromItem := range from { 14882 fromRule = append(fromRule, fromItem) 14883 } 14884 var toRule []interface{} 14885 for _, toItem := range to { 14886 toRule = append(toRule, toItem) 14887 } 14888 14889 logs, sub, err := _WTON.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 14890 if err != nil { 14891 return nil, err 14892 } 14893 return &WTONTransferIterator{contract: _WTON.contract, event: "Transfer", logs: logs, sub: sub}, nil 14894 } 14895 14896 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 14897 // 14898 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 14899 func (_WTON *WTONFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *WTONTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 14900 14901 var fromRule []interface{} 14902 for _, fromItem := range from { 14903 fromRule = append(fromRule, fromItem) 14904 } 14905 var toRule []interface{} 14906 for _, toItem := range to { 14907 toRule = append(toRule, toItem) 14908 } 14909 14910 logs, sub, err := _WTON.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 14911 if err != nil { 14912 return nil, err 14913 } 14914 return event.NewSubscription(func(quit <-chan struct{}) error { 14915 defer sub.Unsubscribe() 14916 for { 14917 select { 14918 case log := <-logs: 14919 // New log arrived, parse the event and forward to the user 14920 event := new(WTONTransfer) 14921 if err := _WTON.contract.UnpackLog(event, "Transfer", log); err != nil { 14922 return err 14923 } 14924 event.Raw = log 14925 14926 select { 14927 case sink <- event: 14928 case err := <-sub.Err(): 14929 return err 14930 case <-quit: 14931 return nil 14932 } 14933 case err := <-sub.Err(): 14934 return err 14935 case <-quit: 14936 return nil 14937 } 14938 } 14939 }), nil 14940 } 14941 14942 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 14943 // 14944 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 14945 func (_WTON *WTONFilterer) ParseTransfer(log types.Log) (*WTONTransfer, error) { 14946 event := new(WTONTransfer) 14947 if err := _WTON.contract.UnpackLog(event, "Transfer", log); err != nil { 14948 return nil, err 14949 } 14950 return event, nil 14951 }