github.com/Onther-Tech/plasma-evm@v0.0.0-rc7.7/contracts/plasma/ton/ton.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 ton 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 // AuthControllerABI is the input ABI used to generate the binding from. 31 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\"}]" 32 33 // AuthControllerFuncSigs maps the 4-byte function signature to its string representation. 34 var AuthControllerFuncSigs = map[string]string{ 35 "8f32d59b": "isOwner()", 36 "8da5cb5b": "owner()", 37 "5f112c68": "renounceMinter(address)", 38 "715018a6": "renounceOwnership()", 39 "38bf3cfa": "renounceOwnership(address)", 40 "41eb24bb": "renouncePauser(address)", 41 "f2fde38b": "transferOwnership(address)", 42 "6d435421": "transferOwnership(address,address)", 43 } 44 45 // AuthControllerBin is the compiled bytecode used for deploying new contracts. 46 var AuthControllerBin = "0x608060405260006100176001600160e01b0361006616565b600080546001600160a01b0319166001600160a01b0383169081178255604051929350917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a35061006a565b3390565b61062f806100796000396000f3fe608060405234801561001057600080fd5b50600436106100885760003560e01c8063715018a61161005b578063715018a61461012f5780638da5cb5b146101375780638f32d59b1461015b578063f2fde38b1461017757610088565b806338bf3cfa1461008d57806341eb24bb146100b55780635f112c68146100db5780636d43542114610101575b600080fd5b6100b3600480360360208110156100a357600080fd5b50356001600160a01b031661019d565b005b6100b3600480360360208110156100cb57600080fd5b50356001600160a01b031661023a565b6100b3600480360360208110156100f157600080fd5b50356001600160a01b03166102bc565b6100b36004803603604081101561011757600080fd5b506001600160a01b038135811691602001351661033e565b6100b36103f9565b61013f61048a565b604080516001600160a01b039092168252519081900360200190f35b610163610499565b604080519115158252519081900360200190f35b6100b36004803603602081101561018d57600080fd5b50356001600160a01b03166104bd565b6101a5610499565b6101e4576040805162461bcd60e51b815260206004820181905260248201526000805160206105db833981519152604482015290519081900360640190fd5b806001600160a01b031663715018a66040518163ffffffff1660e01b8152600401600060405180830381600087803b15801561021f57600080fd5b505af1158015610233573d6000803e3d6000fd5b5050505050565b610242610499565b610281576040805162461bcd60e51b815260206004820181905260248201526000805160206105db833981519152604482015290519081900360640190fd5b806001600160a01b0316636ef8d66d6040518163ffffffff1660e01b8152600401600060405180830381600087803b15801561021f57600080fd5b6102c4610499565b610303576040805162461bcd60e51b815260206004820181905260248201526000805160206105db833981519152604482015290519081900360640190fd5b806001600160a01b031663986502756040518163ffffffff1660e01b8152600401600060405180830381600087803b15801561021f57600080fd5b610346610499565b610385576040805162461bcd60e51b815260206004820181905260248201526000805160206105db833981519152604482015290519081900360640190fd5b816001600160a01b031663f2fde38b826040518263ffffffff1660e01b815260040180826001600160a01b03166001600160a01b03168152602001915050600060405180830381600087803b1580156103dd57600080fd5b505af11580156103f1573d6000803e3d6000fd5b505050505050565b610401610499565b610440576040805162461bcd60e51b815260206004820181905260248201526000805160206105db833981519152604482015290519081900360640190fd5b600080546040516001600160a01b03909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600080546001600160a01b0319169055565b6000546001600160a01b031690565b600080546001600160a01b03166104ae610510565b6001600160a01b031614905090565b6104c5610499565b610504576040805162461bcd60e51b815260206004820181905260248201526000805160206105db833981519152604482015290519081900360640190fd5b61050d81610514565b50565b3390565b6001600160a01b0381166105595760405162461bcd60e51b81526004018080602001828103825260268152602001806105b56026913960400191505060405180910390fd5b600080546040516001600160a01b03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080546001600160a01b0319166001600160a01b039290921691909117905556fe4f776e61626c653a206e6577206f776e657220697320746865207a65726f20616464726573734f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572a265627a7a72315820f5dbf027aa9fb336aafe169eae7ece5653dd467fdb8b8d677f8775fa7b10105264736f6c634300050c0032" 47 48 // DeployAuthController deploys a new Ethereum contract, binding an instance of AuthController to it. 49 func DeployAuthController(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *AuthController, error) { 50 parsed, err := abi.JSON(strings.NewReader(AuthControllerABI)) 51 if err != nil { 52 return common.Address{}, nil, nil, err 53 } 54 55 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(AuthControllerBin), backend) 56 if err != nil { 57 return common.Address{}, nil, nil, err 58 } 59 return address, tx, &AuthController{AuthControllerCaller: AuthControllerCaller{contract: contract}, AuthControllerTransactor: AuthControllerTransactor{contract: contract}, AuthControllerFilterer: AuthControllerFilterer{contract: contract}}, nil 60 } 61 62 // AuthController is an auto generated Go binding around an Ethereum contract. 63 type AuthController struct { 64 AuthControllerCaller // Read-only binding to the contract 65 AuthControllerTransactor // Write-only binding to the contract 66 AuthControllerFilterer // Log filterer for contract events 67 } 68 69 // AuthControllerCaller is an auto generated read-only Go binding around an Ethereum contract. 70 type AuthControllerCaller struct { 71 contract *bind.BoundContract // Generic contract wrapper for the low level calls 72 } 73 74 // AuthControllerTransactor is an auto generated write-only Go binding around an Ethereum contract. 75 type AuthControllerTransactor struct { 76 contract *bind.BoundContract // Generic contract wrapper for the low level calls 77 } 78 79 // AuthControllerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 80 type AuthControllerFilterer struct { 81 contract *bind.BoundContract // Generic contract wrapper for the low level calls 82 } 83 84 // AuthControllerSession is an auto generated Go binding around an Ethereum contract, 85 // with pre-set call and transact options. 86 type AuthControllerSession struct { 87 Contract *AuthController // Generic contract binding to set the session for 88 CallOpts bind.CallOpts // Call options to use throughout this session 89 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 90 } 91 92 // AuthControllerCallerSession is an auto generated read-only Go binding around an Ethereum contract, 93 // with pre-set call options. 94 type AuthControllerCallerSession struct { 95 Contract *AuthControllerCaller // Generic contract caller binding to set the session for 96 CallOpts bind.CallOpts // Call options to use throughout this session 97 } 98 99 // AuthControllerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 100 // with pre-set transact options. 101 type AuthControllerTransactorSession struct { 102 Contract *AuthControllerTransactor // Generic contract transactor binding to set the session for 103 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 104 } 105 106 // AuthControllerRaw is an auto generated low-level Go binding around an Ethereum contract. 107 type AuthControllerRaw struct { 108 Contract *AuthController // Generic contract binding to access the raw methods on 109 } 110 111 // AuthControllerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 112 type AuthControllerCallerRaw struct { 113 Contract *AuthControllerCaller // Generic read-only contract binding to access the raw methods on 114 } 115 116 // AuthControllerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 117 type AuthControllerTransactorRaw struct { 118 Contract *AuthControllerTransactor // Generic write-only contract binding to access the raw methods on 119 } 120 121 // NewAuthController creates a new instance of AuthController, bound to a specific deployed contract. 122 func NewAuthController(address common.Address, backend bind.ContractBackend) (*AuthController, error) { 123 contract, err := bindAuthController(address, backend, backend, backend) 124 if err != nil { 125 return nil, err 126 } 127 return &AuthController{AuthControllerCaller: AuthControllerCaller{contract: contract}, AuthControllerTransactor: AuthControllerTransactor{contract: contract}, AuthControllerFilterer: AuthControllerFilterer{contract: contract}}, nil 128 } 129 130 // NewAuthControllerCaller creates a new read-only instance of AuthController, bound to a specific deployed contract. 131 func NewAuthControllerCaller(address common.Address, caller bind.ContractCaller) (*AuthControllerCaller, error) { 132 contract, err := bindAuthController(address, caller, nil, nil) 133 if err != nil { 134 return nil, err 135 } 136 return &AuthControllerCaller{contract: contract}, nil 137 } 138 139 // NewAuthControllerTransactor creates a new write-only instance of AuthController, bound to a specific deployed contract. 140 func NewAuthControllerTransactor(address common.Address, transactor bind.ContractTransactor) (*AuthControllerTransactor, error) { 141 contract, err := bindAuthController(address, nil, transactor, nil) 142 if err != nil { 143 return nil, err 144 } 145 return &AuthControllerTransactor{contract: contract}, nil 146 } 147 148 // NewAuthControllerFilterer creates a new log filterer instance of AuthController, bound to a specific deployed contract. 149 func NewAuthControllerFilterer(address common.Address, filterer bind.ContractFilterer) (*AuthControllerFilterer, error) { 150 contract, err := bindAuthController(address, nil, nil, filterer) 151 if err != nil { 152 return nil, err 153 } 154 return &AuthControllerFilterer{contract: contract}, nil 155 } 156 157 // bindAuthController binds a generic wrapper to an already deployed contract. 158 func bindAuthController(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 159 parsed, err := abi.JSON(strings.NewReader(AuthControllerABI)) 160 if err != nil { 161 return nil, err 162 } 163 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 164 } 165 166 // Call invokes the (constant) contract method with params as input values and 167 // sets the output to result. The result type might be a single field for simple 168 // returns, a slice of interfaces for anonymous returns and a struct for named 169 // returns. 170 func (_AuthController *AuthControllerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 171 return _AuthController.Contract.AuthControllerCaller.contract.Call(opts, result, method, params...) 172 } 173 174 // Transfer initiates a plain transaction to move funds to the contract, calling 175 // its default method if one is available. 176 func (_AuthController *AuthControllerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 177 return _AuthController.Contract.AuthControllerTransactor.contract.Transfer(opts) 178 } 179 180 // Transact invokes the (paid) contract method with params as input values. 181 func (_AuthController *AuthControllerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 182 return _AuthController.Contract.AuthControllerTransactor.contract.Transact(opts, method, params...) 183 } 184 185 // Call invokes the (constant) contract method with params as input values and 186 // sets the output to result. The result type might be a single field for simple 187 // returns, a slice of interfaces for anonymous returns and a struct for named 188 // returns. 189 func (_AuthController *AuthControllerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 190 return _AuthController.Contract.contract.Call(opts, result, method, params...) 191 } 192 193 // Transfer initiates a plain transaction to move funds to the contract, calling 194 // its default method if one is available. 195 func (_AuthController *AuthControllerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 196 return _AuthController.Contract.contract.Transfer(opts) 197 } 198 199 // Transact invokes the (paid) contract method with params as input values. 200 func (_AuthController *AuthControllerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 201 return _AuthController.Contract.contract.Transact(opts, method, params...) 202 } 203 204 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 205 // 206 // Solidity: function isOwner() constant returns(bool) 207 func (_AuthController *AuthControllerCaller) IsOwner(opts *bind.CallOpts) (bool, error) { 208 var ( 209 ret0 = new(bool) 210 ) 211 out := ret0 212 err := _AuthController.contract.Call(opts, out, "isOwner") 213 return *ret0, err 214 } 215 216 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 217 // 218 // Solidity: function isOwner() constant returns(bool) 219 func (_AuthController *AuthControllerSession) IsOwner() (bool, error) { 220 return _AuthController.Contract.IsOwner(&_AuthController.CallOpts) 221 } 222 223 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 224 // 225 // Solidity: function isOwner() constant returns(bool) 226 func (_AuthController *AuthControllerCallerSession) IsOwner() (bool, error) { 227 return _AuthController.Contract.IsOwner(&_AuthController.CallOpts) 228 } 229 230 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 231 // 232 // Solidity: function owner() constant returns(address) 233 func (_AuthController *AuthControllerCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 234 var ( 235 ret0 = new(common.Address) 236 ) 237 out := ret0 238 err := _AuthController.contract.Call(opts, out, "owner") 239 return *ret0, err 240 } 241 242 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 243 // 244 // Solidity: function owner() constant returns(address) 245 func (_AuthController *AuthControllerSession) Owner() (common.Address, error) { 246 return _AuthController.Contract.Owner(&_AuthController.CallOpts) 247 } 248 249 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 250 // 251 // Solidity: function owner() constant returns(address) 252 func (_AuthController *AuthControllerCallerSession) Owner() (common.Address, error) { 253 return _AuthController.Contract.Owner(&_AuthController.CallOpts) 254 } 255 256 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 257 // 258 // Solidity: function renounceMinter(address target) returns() 259 func (_AuthController *AuthControllerTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 260 return _AuthController.contract.Transact(opts, "renounceMinter", target) 261 } 262 263 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 264 // 265 // Solidity: function renounceMinter(address target) returns() 266 func (_AuthController *AuthControllerSession) RenounceMinter(target common.Address) (*types.Transaction, error) { 267 return _AuthController.Contract.RenounceMinter(&_AuthController.TransactOpts, target) 268 } 269 270 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 271 // 272 // Solidity: function renounceMinter(address target) returns() 273 func (_AuthController *AuthControllerTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) { 274 return _AuthController.Contract.RenounceMinter(&_AuthController.TransactOpts, target) 275 } 276 277 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 278 // 279 // Solidity: function renounceOwnership(address target) returns() 280 func (_AuthController *AuthControllerTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 281 return _AuthController.contract.Transact(opts, "renounceOwnership", target) 282 } 283 284 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 285 // 286 // Solidity: function renounceOwnership(address target) returns() 287 func (_AuthController *AuthControllerSession) RenounceOwnership(target common.Address) (*types.Transaction, error) { 288 return _AuthController.Contract.RenounceOwnership(&_AuthController.TransactOpts, target) 289 } 290 291 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 292 // 293 // Solidity: function renounceOwnership(address target) returns() 294 func (_AuthController *AuthControllerTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) { 295 return _AuthController.Contract.RenounceOwnership(&_AuthController.TransactOpts, target) 296 } 297 298 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 299 // 300 // Solidity: function renounceOwnership() returns() 301 func (_AuthController *AuthControllerTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) { 302 return _AuthController.contract.Transact(opts, "renounceOwnership0") 303 } 304 305 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 306 // 307 // Solidity: function renounceOwnership() returns() 308 func (_AuthController *AuthControllerSession) RenounceOwnership0() (*types.Transaction, error) { 309 return _AuthController.Contract.RenounceOwnership0(&_AuthController.TransactOpts) 310 } 311 312 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 313 // 314 // Solidity: function renounceOwnership() returns() 315 func (_AuthController *AuthControllerTransactorSession) RenounceOwnership0() (*types.Transaction, error) { 316 return _AuthController.Contract.RenounceOwnership0(&_AuthController.TransactOpts) 317 } 318 319 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 320 // 321 // Solidity: function renouncePauser(address target) returns() 322 func (_AuthController *AuthControllerTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 323 return _AuthController.contract.Transact(opts, "renouncePauser", target) 324 } 325 326 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 327 // 328 // Solidity: function renouncePauser(address target) returns() 329 func (_AuthController *AuthControllerSession) RenouncePauser(target common.Address) (*types.Transaction, error) { 330 return _AuthController.Contract.RenouncePauser(&_AuthController.TransactOpts, target) 331 } 332 333 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 334 // 335 // Solidity: function renouncePauser(address target) returns() 336 func (_AuthController *AuthControllerTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) { 337 return _AuthController.Contract.RenouncePauser(&_AuthController.TransactOpts, target) 338 } 339 340 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 341 // 342 // Solidity: function transferOwnership(address target, address newOwner) returns() 343 func (_AuthController *AuthControllerTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) { 344 return _AuthController.contract.Transact(opts, "transferOwnership", target, newOwner) 345 } 346 347 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 348 // 349 // Solidity: function transferOwnership(address target, address newOwner) returns() 350 func (_AuthController *AuthControllerSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) { 351 return _AuthController.Contract.TransferOwnership(&_AuthController.TransactOpts, target, newOwner) 352 } 353 354 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 355 // 356 // Solidity: function transferOwnership(address target, address newOwner) returns() 357 func (_AuthController *AuthControllerTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) { 358 return _AuthController.Contract.TransferOwnership(&_AuthController.TransactOpts, target, newOwner) 359 } 360 361 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 362 // 363 // Solidity: function transferOwnership(address newOwner) returns() 364 func (_AuthController *AuthControllerTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 365 return _AuthController.contract.Transact(opts, "transferOwnership0", newOwner) 366 } 367 368 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 369 // 370 // Solidity: function transferOwnership(address newOwner) returns() 371 func (_AuthController *AuthControllerSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) { 372 return _AuthController.Contract.TransferOwnership0(&_AuthController.TransactOpts, newOwner) 373 } 374 375 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 376 // 377 // Solidity: function transferOwnership(address newOwner) returns() 378 func (_AuthController *AuthControllerTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) { 379 return _AuthController.Contract.TransferOwnership0(&_AuthController.TransactOpts, newOwner) 380 } 381 382 // 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. 383 type AuthControllerOwnershipTransferredIterator struct { 384 Event *AuthControllerOwnershipTransferred // Event containing the contract specifics and raw log 385 386 contract *bind.BoundContract // Generic contract to use for unpacking event data 387 event string // Event name to use for unpacking event data 388 389 logs chan types.Log // Log channel receiving the found contract events 390 sub ethereum.Subscription // Subscription for errors, completion and termination 391 done bool // Whether the subscription completed delivering logs 392 fail error // Occurred error to stop iteration 393 } 394 395 // Next advances the iterator to the subsequent event, returning whether there 396 // are any more events found. In case of a retrieval or parsing error, false is 397 // returned and Error() can be queried for the exact failure. 398 func (it *AuthControllerOwnershipTransferredIterator) Next() bool { 399 // If the iterator failed, stop iterating 400 if it.fail != nil { 401 return false 402 } 403 // If the iterator completed, deliver directly whatever's available 404 if it.done { 405 select { 406 case log := <-it.logs: 407 it.Event = new(AuthControllerOwnershipTransferred) 408 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 409 it.fail = err 410 return false 411 } 412 it.Event.Raw = log 413 return true 414 415 default: 416 return false 417 } 418 } 419 // Iterator still in progress, wait for either a data or an error event 420 select { 421 case log := <-it.logs: 422 it.Event = new(AuthControllerOwnershipTransferred) 423 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 424 it.fail = err 425 return false 426 } 427 it.Event.Raw = log 428 return true 429 430 case err := <-it.sub.Err(): 431 it.done = true 432 it.fail = err 433 return it.Next() 434 } 435 } 436 437 // Error returns any retrieval or parsing error occurred during filtering. 438 func (it *AuthControllerOwnershipTransferredIterator) Error() error { 439 return it.fail 440 } 441 442 // Close terminates the iteration process, releasing any pending underlying 443 // resources. 444 func (it *AuthControllerOwnershipTransferredIterator) Close() error { 445 it.sub.Unsubscribe() 446 return nil 447 } 448 449 // AuthControllerOwnershipTransferred represents a OwnershipTransferred event raised by the AuthController contract. 450 type AuthControllerOwnershipTransferred struct { 451 PreviousOwner common.Address 452 NewOwner common.Address 453 Raw types.Log // Blockchain specific contextual infos 454 } 455 456 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 457 // 458 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 459 func (_AuthController *AuthControllerFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*AuthControllerOwnershipTransferredIterator, error) { 460 461 var previousOwnerRule []interface{} 462 for _, previousOwnerItem := range previousOwner { 463 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 464 } 465 var newOwnerRule []interface{} 466 for _, newOwnerItem := range newOwner { 467 newOwnerRule = append(newOwnerRule, newOwnerItem) 468 } 469 470 logs, sub, err := _AuthController.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 471 if err != nil { 472 return nil, err 473 } 474 return &AuthControllerOwnershipTransferredIterator{contract: _AuthController.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 475 } 476 477 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 478 // 479 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 480 func (_AuthController *AuthControllerFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *AuthControllerOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 481 482 var previousOwnerRule []interface{} 483 for _, previousOwnerItem := range previousOwner { 484 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 485 } 486 var newOwnerRule []interface{} 487 for _, newOwnerItem := range newOwner { 488 newOwnerRule = append(newOwnerRule, newOwnerItem) 489 } 490 491 logs, sub, err := _AuthController.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 492 if err != nil { 493 return nil, err 494 } 495 return event.NewSubscription(func(quit <-chan struct{}) error { 496 defer sub.Unsubscribe() 497 for { 498 select { 499 case log := <-logs: 500 // New log arrived, parse the event and forward to the user 501 event := new(AuthControllerOwnershipTransferred) 502 if err := _AuthController.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 503 return err 504 } 505 event.Raw = log 506 507 select { 508 case sink <- event: 509 case err := <-sub.Err(): 510 return err 511 case <-quit: 512 return nil 513 } 514 case err := <-sub.Err(): 515 return err 516 case <-quit: 517 return nil 518 } 519 } 520 }), nil 521 } 522 523 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 524 // 525 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 526 func (_AuthController *AuthControllerFilterer) ParseOwnershipTransferred(log types.Log) (*AuthControllerOwnershipTransferred, error) { 527 event := new(AuthControllerOwnershipTransferred) 528 if err := _AuthController.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 529 return nil, err 530 } 531 return event, nil 532 } 533 534 // ContextABI is the input ABI used to generate the binding from. 535 const ContextABI = "[{\"inputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"constructor\"}]" 536 537 // Context is an auto generated Go binding around an Ethereum contract. 538 type Context struct { 539 ContextCaller // Read-only binding to the contract 540 ContextTransactor // Write-only binding to the contract 541 ContextFilterer // Log filterer for contract events 542 } 543 544 // ContextCaller is an auto generated read-only Go binding around an Ethereum contract. 545 type ContextCaller struct { 546 contract *bind.BoundContract // Generic contract wrapper for the low level calls 547 } 548 549 // ContextTransactor is an auto generated write-only Go binding around an Ethereum contract. 550 type ContextTransactor struct { 551 contract *bind.BoundContract // Generic contract wrapper for the low level calls 552 } 553 554 // ContextFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 555 type ContextFilterer struct { 556 contract *bind.BoundContract // Generic contract wrapper for the low level calls 557 } 558 559 // ContextSession is an auto generated Go binding around an Ethereum contract, 560 // with pre-set call and transact options. 561 type ContextSession struct { 562 Contract *Context // Generic contract binding to set the session for 563 CallOpts bind.CallOpts // Call options to use throughout this session 564 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 565 } 566 567 // ContextCallerSession is an auto generated read-only Go binding around an Ethereum contract, 568 // with pre-set call options. 569 type ContextCallerSession struct { 570 Contract *ContextCaller // Generic contract caller binding to set the session for 571 CallOpts bind.CallOpts // Call options to use throughout this session 572 } 573 574 // ContextTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 575 // with pre-set transact options. 576 type ContextTransactorSession struct { 577 Contract *ContextTransactor // Generic contract transactor binding to set the session for 578 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 579 } 580 581 // ContextRaw is an auto generated low-level Go binding around an Ethereum contract. 582 type ContextRaw struct { 583 Contract *Context // Generic contract binding to access the raw methods on 584 } 585 586 // ContextCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 587 type ContextCallerRaw struct { 588 Contract *ContextCaller // Generic read-only contract binding to access the raw methods on 589 } 590 591 // ContextTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 592 type ContextTransactorRaw struct { 593 Contract *ContextTransactor // Generic write-only contract binding to access the raw methods on 594 } 595 596 // NewContext creates a new instance of Context, bound to a specific deployed contract. 597 func NewContext(address common.Address, backend bind.ContractBackend) (*Context, error) { 598 contract, err := bindContext(address, backend, backend, backend) 599 if err != nil { 600 return nil, err 601 } 602 return &Context{ContextCaller: ContextCaller{contract: contract}, ContextTransactor: ContextTransactor{contract: contract}, ContextFilterer: ContextFilterer{contract: contract}}, nil 603 } 604 605 // NewContextCaller creates a new read-only instance of Context, bound to a specific deployed contract. 606 func NewContextCaller(address common.Address, caller bind.ContractCaller) (*ContextCaller, error) { 607 contract, err := bindContext(address, caller, nil, nil) 608 if err != nil { 609 return nil, err 610 } 611 return &ContextCaller{contract: contract}, nil 612 } 613 614 // NewContextTransactor creates a new write-only instance of Context, bound to a specific deployed contract. 615 func NewContextTransactor(address common.Address, transactor bind.ContractTransactor) (*ContextTransactor, error) { 616 contract, err := bindContext(address, nil, transactor, nil) 617 if err != nil { 618 return nil, err 619 } 620 return &ContextTransactor{contract: contract}, nil 621 } 622 623 // NewContextFilterer creates a new log filterer instance of Context, bound to a specific deployed contract. 624 func NewContextFilterer(address common.Address, filterer bind.ContractFilterer) (*ContextFilterer, error) { 625 contract, err := bindContext(address, nil, nil, filterer) 626 if err != nil { 627 return nil, err 628 } 629 return &ContextFilterer{contract: contract}, nil 630 } 631 632 // bindContext binds a generic wrapper to an already deployed contract. 633 func bindContext(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 634 parsed, err := abi.JSON(strings.NewReader(ContextABI)) 635 if err != nil { 636 return nil, err 637 } 638 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 639 } 640 641 // Call invokes the (constant) contract method with params as input values and 642 // sets the output to result. The result type might be a single field for simple 643 // returns, a slice of interfaces for anonymous returns and a struct for named 644 // returns. 645 func (_Context *ContextRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 646 return _Context.Contract.ContextCaller.contract.Call(opts, result, method, params...) 647 } 648 649 // Transfer initiates a plain transaction to move funds to the contract, calling 650 // its default method if one is available. 651 func (_Context *ContextRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 652 return _Context.Contract.ContextTransactor.contract.Transfer(opts) 653 } 654 655 // Transact invokes the (paid) contract method with params as input values. 656 func (_Context *ContextRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 657 return _Context.Contract.ContextTransactor.contract.Transact(opts, method, params...) 658 } 659 660 // Call invokes the (constant) contract method with params as input values and 661 // sets the output to result. The result type might be a single field for simple 662 // returns, a slice of interfaces for anonymous returns and a struct for named 663 // returns. 664 func (_Context *ContextCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 665 return _Context.Contract.contract.Call(opts, result, method, params...) 666 } 667 668 // Transfer initiates a plain transaction to move funds to the contract, calling 669 // its default method if one is available. 670 func (_Context *ContextTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 671 return _Context.Contract.contract.Transfer(opts) 672 } 673 674 // Transact invokes the (paid) contract method with params as input values. 675 func (_Context *ContextTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 676 return _Context.Contract.contract.Transact(opts, method, params...) 677 } 678 679 // ERC165CheckerABI is the input ABI used to generate the binding from. 680 const ERC165CheckerABI = "[]" 681 682 // ERC165CheckerBin is the compiled bytecode used for deploying new contracts. 683 var ERC165CheckerBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a72315820ea851d268567a3ed8f55b193eb1a6f3028b7565ea2152c791833f991fbaa44e864736f6c634300050c0032" 684 685 // DeployERC165Checker deploys a new Ethereum contract, binding an instance of ERC165Checker to it. 686 func DeployERC165Checker(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC165Checker, error) { 687 parsed, err := abi.JSON(strings.NewReader(ERC165CheckerABI)) 688 if err != nil { 689 return common.Address{}, nil, nil, err 690 } 691 692 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC165CheckerBin), backend) 693 if err != nil { 694 return common.Address{}, nil, nil, err 695 } 696 return address, tx, &ERC165Checker{ERC165CheckerCaller: ERC165CheckerCaller{contract: contract}, ERC165CheckerTransactor: ERC165CheckerTransactor{contract: contract}, ERC165CheckerFilterer: ERC165CheckerFilterer{contract: contract}}, nil 697 } 698 699 // ERC165Checker is an auto generated Go binding around an Ethereum contract. 700 type ERC165Checker struct { 701 ERC165CheckerCaller // Read-only binding to the contract 702 ERC165CheckerTransactor // Write-only binding to the contract 703 ERC165CheckerFilterer // Log filterer for contract events 704 } 705 706 // ERC165CheckerCaller is an auto generated read-only Go binding around an Ethereum contract. 707 type ERC165CheckerCaller struct { 708 contract *bind.BoundContract // Generic contract wrapper for the low level calls 709 } 710 711 // ERC165CheckerTransactor is an auto generated write-only Go binding around an Ethereum contract. 712 type ERC165CheckerTransactor struct { 713 contract *bind.BoundContract // Generic contract wrapper for the low level calls 714 } 715 716 // ERC165CheckerFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 717 type ERC165CheckerFilterer struct { 718 contract *bind.BoundContract // Generic contract wrapper for the low level calls 719 } 720 721 // ERC165CheckerSession is an auto generated Go binding around an Ethereum contract, 722 // with pre-set call and transact options. 723 type ERC165CheckerSession struct { 724 Contract *ERC165Checker // 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 // ERC165CheckerCallerSession is an auto generated read-only Go binding around an Ethereum contract, 730 // with pre-set call options. 731 type ERC165CheckerCallerSession struct { 732 Contract *ERC165CheckerCaller // Generic contract caller binding to set the session for 733 CallOpts bind.CallOpts // Call options to use throughout this session 734 } 735 736 // ERC165CheckerTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 737 // with pre-set transact options. 738 type ERC165CheckerTransactorSession struct { 739 Contract *ERC165CheckerTransactor // Generic contract transactor binding to set the session for 740 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 741 } 742 743 // ERC165CheckerRaw is an auto generated low-level Go binding around an Ethereum contract. 744 type ERC165CheckerRaw struct { 745 Contract *ERC165Checker // Generic contract binding to access the raw methods on 746 } 747 748 // ERC165CheckerCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 749 type ERC165CheckerCallerRaw struct { 750 Contract *ERC165CheckerCaller // Generic read-only contract binding to access the raw methods on 751 } 752 753 // ERC165CheckerTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 754 type ERC165CheckerTransactorRaw struct { 755 Contract *ERC165CheckerTransactor // Generic write-only contract binding to access the raw methods on 756 } 757 758 // NewERC165Checker creates a new instance of ERC165Checker, bound to a specific deployed contract. 759 func NewERC165Checker(address common.Address, backend bind.ContractBackend) (*ERC165Checker, error) { 760 contract, err := bindERC165Checker(address, backend, backend, backend) 761 if err != nil { 762 return nil, err 763 } 764 return &ERC165Checker{ERC165CheckerCaller: ERC165CheckerCaller{contract: contract}, ERC165CheckerTransactor: ERC165CheckerTransactor{contract: contract}, ERC165CheckerFilterer: ERC165CheckerFilterer{contract: contract}}, nil 765 } 766 767 // NewERC165CheckerCaller creates a new read-only instance of ERC165Checker, bound to a specific deployed contract. 768 func NewERC165CheckerCaller(address common.Address, caller bind.ContractCaller) (*ERC165CheckerCaller, error) { 769 contract, err := bindERC165Checker(address, caller, nil, nil) 770 if err != nil { 771 return nil, err 772 } 773 return &ERC165CheckerCaller{contract: contract}, nil 774 } 775 776 // NewERC165CheckerTransactor creates a new write-only instance of ERC165Checker, bound to a specific deployed contract. 777 func NewERC165CheckerTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC165CheckerTransactor, error) { 778 contract, err := bindERC165Checker(address, nil, transactor, nil) 779 if err != nil { 780 return nil, err 781 } 782 return &ERC165CheckerTransactor{contract: contract}, nil 783 } 784 785 // NewERC165CheckerFilterer creates a new log filterer instance of ERC165Checker, bound to a specific deployed contract. 786 func NewERC165CheckerFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC165CheckerFilterer, error) { 787 contract, err := bindERC165Checker(address, nil, nil, filterer) 788 if err != nil { 789 return nil, err 790 } 791 return &ERC165CheckerFilterer{contract: contract}, nil 792 } 793 794 // bindERC165Checker binds a generic wrapper to an already deployed contract. 795 func bindERC165Checker(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 796 parsed, err := abi.JSON(strings.NewReader(ERC165CheckerABI)) 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 (_ERC165Checker *ERC165CheckerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 808 return _ERC165Checker.Contract.ERC165CheckerCaller.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 (_ERC165Checker *ERC165CheckerRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 814 return _ERC165Checker.Contract.ERC165CheckerTransactor.contract.Transfer(opts) 815 } 816 817 // Transact invokes the (paid) contract method with params as input values. 818 func (_ERC165Checker *ERC165CheckerRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 819 return _ERC165Checker.Contract.ERC165CheckerTransactor.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 (_ERC165Checker *ERC165CheckerCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 827 return _ERC165Checker.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 (_ERC165Checker *ERC165CheckerTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 833 return _ERC165Checker.Contract.contract.Transfer(opts) 834 } 835 836 // Transact invokes the (paid) contract method with params as input values. 837 func (_ERC165Checker *ERC165CheckerTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 838 return _ERC165Checker.Contract.contract.Transact(opts, method, params...) 839 } 840 841 // ERC20ABI is the input ABI used to generate the binding from. 842 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\"}]" 843 844 // ERC20FuncSigs maps the 4-byte function signature to its string representation. 845 var ERC20FuncSigs = map[string]string{ 846 "dd62ed3e": "allowance(address,address)", 847 "095ea7b3": "approve(address,uint256)", 848 "70a08231": "balanceOf(address)", 849 "a457c2d7": "decreaseAllowance(address,uint256)", 850 "39509351": "increaseAllowance(address,uint256)", 851 "18160ddd": "totalSupply()", 852 "a9059cbb": "transfer(address,uint256)", 853 "23b872dd": "transferFrom(address,address,uint256)", 854 } 855 856 // ERC20Bin is the compiled bytecode used for deploying new contracts. 857 var ERC20Bin = "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" 858 859 // DeployERC20 deploys a new Ethereum contract, binding an instance of ERC20 to it. 860 func DeployERC20(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20, error) { 861 parsed, err := abi.JSON(strings.NewReader(ERC20ABI)) 862 if err != nil { 863 return common.Address{}, nil, nil, err 864 } 865 866 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20Bin), backend) 867 if err != nil { 868 return common.Address{}, nil, nil, err 869 } 870 return address, tx, &ERC20{ERC20Caller: ERC20Caller{contract: contract}, ERC20Transactor: ERC20Transactor{contract: contract}, ERC20Filterer: ERC20Filterer{contract: contract}}, nil 871 } 872 873 // ERC20 is an auto generated Go binding around an Ethereum contract. 874 type ERC20 struct { 875 ERC20Caller // Read-only binding to the contract 876 ERC20Transactor // Write-only binding to the contract 877 ERC20Filterer // Log filterer for contract events 878 } 879 880 // ERC20Caller is an auto generated read-only Go binding around an Ethereum contract. 881 type ERC20Caller struct { 882 contract *bind.BoundContract // Generic contract wrapper for the low level calls 883 } 884 885 // ERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. 886 type ERC20Transactor struct { 887 contract *bind.BoundContract // Generic contract wrapper for the low level calls 888 } 889 890 // ERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. 891 type ERC20Filterer struct { 892 contract *bind.BoundContract // Generic contract wrapper for the low level calls 893 } 894 895 // ERC20Session is an auto generated Go binding around an Ethereum contract, 896 // with pre-set call and transact options. 897 type ERC20Session struct { 898 Contract *ERC20 // Generic contract binding to set the session for 899 CallOpts bind.CallOpts // Call options to use throughout this session 900 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 901 } 902 903 // ERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, 904 // with pre-set call options. 905 type ERC20CallerSession struct { 906 Contract *ERC20Caller // Generic contract caller binding to set the session for 907 CallOpts bind.CallOpts // Call options to use throughout this session 908 } 909 910 // ERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, 911 // with pre-set transact options. 912 type ERC20TransactorSession struct { 913 Contract *ERC20Transactor // Generic contract transactor binding to set the session for 914 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 915 } 916 917 // ERC20Raw is an auto generated low-level Go binding around an Ethereum contract. 918 type ERC20Raw struct { 919 Contract *ERC20 // Generic contract binding to access the raw methods on 920 } 921 922 // ERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 923 type ERC20CallerRaw struct { 924 Contract *ERC20Caller // Generic read-only contract binding to access the raw methods on 925 } 926 927 // ERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 928 type ERC20TransactorRaw struct { 929 Contract *ERC20Transactor // Generic write-only contract binding to access the raw methods on 930 } 931 932 // NewERC20 creates a new instance of ERC20, bound to a specific deployed contract. 933 func NewERC20(address common.Address, backend bind.ContractBackend) (*ERC20, error) { 934 contract, err := bindERC20(address, backend, backend, backend) 935 if err != nil { 936 return nil, err 937 } 938 return &ERC20{ERC20Caller: ERC20Caller{contract: contract}, ERC20Transactor: ERC20Transactor{contract: contract}, ERC20Filterer: ERC20Filterer{contract: contract}}, nil 939 } 940 941 // NewERC20Caller creates a new read-only instance of ERC20, bound to a specific deployed contract. 942 func NewERC20Caller(address common.Address, caller bind.ContractCaller) (*ERC20Caller, error) { 943 contract, err := bindERC20(address, caller, nil, nil) 944 if err != nil { 945 return nil, err 946 } 947 return &ERC20Caller{contract: contract}, nil 948 } 949 950 // NewERC20Transactor creates a new write-only instance of ERC20, bound to a specific deployed contract. 951 func NewERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*ERC20Transactor, error) { 952 contract, err := bindERC20(address, nil, transactor, nil) 953 if err != nil { 954 return nil, err 955 } 956 return &ERC20Transactor{contract: contract}, nil 957 } 958 959 // NewERC20Filterer creates a new log filterer instance of ERC20, bound to a specific deployed contract. 960 func NewERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*ERC20Filterer, error) { 961 contract, err := bindERC20(address, nil, nil, filterer) 962 if err != nil { 963 return nil, err 964 } 965 return &ERC20Filterer{contract: contract}, nil 966 } 967 968 // bindERC20 binds a generic wrapper to an already deployed contract. 969 func bindERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 970 parsed, err := abi.JSON(strings.NewReader(ERC20ABI)) 971 if err != nil { 972 return nil, err 973 } 974 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 975 } 976 977 // Call invokes the (constant) contract method with params as input values and 978 // sets the output to result. The result type might be a single field for simple 979 // returns, a slice of interfaces for anonymous returns and a struct for named 980 // returns. 981 func (_ERC20 *ERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 982 return _ERC20.Contract.ERC20Caller.contract.Call(opts, result, method, params...) 983 } 984 985 // Transfer initiates a plain transaction to move funds to the contract, calling 986 // its default method if one is available. 987 func (_ERC20 *ERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 988 return _ERC20.Contract.ERC20Transactor.contract.Transfer(opts) 989 } 990 991 // Transact invokes the (paid) contract method with params as input values. 992 func (_ERC20 *ERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 993 return _ERC20.Contract.ERC20Transactor.contract.Transact(opts, method, params...) 994 } 995 996 // Call invokes the (constant) contract method with params as input values and 997 // sets the output to result. The result type might be a single field for simple 998 // returns, a slice of interfaces for anonymous returns and a struct for named 999 // returns. 1000 func (_ERC20 *ERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 1001 return _ERC20.Contract.contract.Call(opts, result, method, params...) 1002 } 1003 1004 // Transfer initiates a plain transaction to move funds to the contract, calling 1005 // its default method if one is available. 1006 func (_ERC20 *ERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1007 return _ERC20.Contract.contract.Transfer(opts) 1008 } 1009 1010 // Transact invokes the (paid) contract method with params as input values. 1011 func (_ERC20 *ERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1012 return _ERC20.Contract.contract.Transact(opts, method, params...) 1013 } 1014 1015 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 1016 // 1017 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 1018 func (_ERC20 *ERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 1019 var ( 1020 ret0 = new(*big.Int) 1021 ) 1022 out := ret0 1023 err := _ERC20.contract.Call(opts, out, "allowance", owner, spender) 1024 return *ret0, err 1025 } 1026 1027 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 1028 // 1029 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 1030 func (_ERC20 *ERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 1031 return _ERC20.Contract.Allowance(&_ERC20.CallOpts, owner, spender) 1032 } 1033 1034 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 1035 // 1036 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 1037 func (_ERC20 *ERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 1038 return _ERC20.Contract.Allowance(&_ERC20.CallOpts, owner, spender) 1039 } 1040 1041 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1042 // 1043 // Solidity: function balanceOf(address account) constant returns(uint256) 1044 func (_ERC20 *ERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 1045 var ( 1046 ret0 = new(*big.Int) 1047 ) 1048 out := ret0 1049 err := _ERC20.contract.Call(opts, out, "balanceOf", account) 1050 return *ret0, err 1051 } 1052 1053 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1054 // 1055 // Solidity: function balanceOf(address account) constant returns(uint256) 1056 func (_ERC20 *ERC20Session) BalanceOf(account common.Address) (*big.Int, error) { 1057 return _ERC20.Contract.BalanceOf(&_ERC20.CallOpts, account) 1058 } 1059 1060 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1061 // 1062 // Solidity: function balanceOf(address account) constant returns(uint256) 1063 func (_ERC20 *ERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { 1064 return _ERC20.Contract.BalanceOf(&_ERC20.CallOpts, account) 1065 } 1066 1067 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1068 // 1069 // Solidity: function totalSupply() constant returns(uint256) 1070 func (_ERC20 *ERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 1071 var ( 1072 ret0 = new(*big.Int) 1073 ) 1074 out := ret0 1075 err := _ERC20.contract.Call(opts, out, "totalSupply") 1076 return *ret0, err 1077 } 1078 1079 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1080 // 1081 // Solidity: function totalSupply() constant returns(uint256) 1082 func (_ERC20 *ERC20Session) TotalSupply() (*big.Int, error) { 1083 return _ERC20.Contract.TotalSupply(&_ERC20.CallOpts) 1084 } 1085 1086 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1087 // 1088 // Solidity: function totalSupply() constant returns(uint256) 1089 func (_ERC20 *ERC20CallerSession) TotalSupply() (*big.Int, error) { 1090 return _ERC20.Contract.TotalSupply(&_ERC20.CallOpts) 1091 } 1092 1093 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 1094 // 1095 // Solidity: function approve(address spender, uint256 amount) returns(bool) 1096 func (_ERC20 *ERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 1097 return _ERC20.contract.Transact(opts, "approve", spender, amount) 1098 } 1099 1100 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 1101 // 1102 // Solidity: function approve(address spender, uint256 amount) returns(bool) 1103 func (_ERC20 *ERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 1104 return _ERC20.Contract.Approve(&_ERC20.TransactOpts, spender, amount) 1105 } 1106 1107 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 1108 // 1109 // Solidity: function approve(address spender, uint256 amount) returns(bool) 1110 func (_ERC20 *ERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 1111 return _ERC20.Contract.Approve(&_ERC20.TransactOpts, spender, amount) 1112 } 1113 1114 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 1115 // 1116 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 1117 func (_ERC20 *ERC20Transactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 1118 return _ERC20.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) 1119 } 1120 1121 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 1122 // 1123 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 1124 func (_ERC20 *ERC20Session) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 1125 return _ERC20.Contract.DecreaseAllowance(&_ERC20.TransactOpts, spender, subtractedValue) 1126 } 1127 1128 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 1129 // 1130 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 1131 func (_ERC20 *ERC20TransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 1132 return _ERC20.Contract.DecreaseAllowance(&_ERC20.TransactOpts, spender, subtractedValue) 1133 } 1134 1135 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 1136 // 1137 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 1138 func (_ERC20 *ERC20Transactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 1139 return _ERC20.contract.Transact(opts, "increaseAllowance", spender, addedValue) 1140 } 1141 1142 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 1143 // 1144 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 1145 func (_ERC20 *ERC20Session) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 1146 return _ERC20.Contract.IncreaseAllowance(&_ERC20.TransactOpts, spender, addedValue) 1147 } 1148 1149 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 1150 // 1151 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 1152 func (_ERC20 *ERC20TransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 1153 return _ERC20.Contract.IncreaseAllowance(&_ERC20.TransactOpts, spender, addedValue) 1154 } 1155 1156 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1157 // 1158 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 1159 func (_ERC20 *ERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1160 return _ERC20.contract.Transact(opts, "transfer", recipient, amount) 1161 } 1162 1163 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1164 // 1165 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 1166 func (_ERC20 *ERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1167 return _ERC20.Contract.Transfer(&_ERC20.TransactOpts, recipient, amount) 1168 } 1169 1170 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1171 // 1172 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 1173 func (_ERC20 *ERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1174 return _ERC20.Contract.Transfer(&_ERC20.TransactOpts, recipient, amount) 1175 } 1176 1177 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 1178 // 1179 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 1180 func (_ERC20 *ERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1181 return _ERC20.contract.Transact(opts, "transferFrom", sender, recipient, amount) 1182 } 1183 1184 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 1185 // 1186 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 1187 func (_ERC20 *ERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1188 return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, sender, recipient, amount) 1189 } 1190 1191 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 1192 // 1193 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 1194 func (_ERC20 *ERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1195 return _ERC20.Contract.TransferFrom(&_ERC20.TransactOpts, sender, recipient, amount) 1196 } 1197 1198 // 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. 1199 type ERC20ApprovalIterator struct { 1200 Event *ERC20Approval // Event containing the contract specifics and raw log 1201 1202 contract *bind.BoundContract // Generic contract to use for unpacking event data 1203 event string // Event name to use for unpacking event data 1204 1205 logs chan types.Log // Log channel receiving the found contract events 1206 sub ethereum.Subscription // Subscription for errors, completion and termination 1207 done bool // Whether the subscription completed delivering logs 1208 fail error // Occurred error to stop iteration 1209 } 1210 1211 // Next advances the iterator to the subsequent event, returning whether there 1212 // are any more events found. In case of a retrieval or parsing error, false is 1213 // returned and Error() can be queried for the exact failure. 1214 func (it *ERC20ApprovalIterator) Next() bool { 1215 // If the iterator failed, stop iterating 1216 if it.fail != nil { 1217 return false 1218 } 1219 // If the iterator completed, deliver directly whatever's available 1220 if it.done { 1221 select { 1222 case log := <-it.logs: 1223 it.Event = new(ERC20Approval) 1224 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1225 it.fail = err 1226 return false 1227 } 1228 it.Event.Raw = log 1229 return true 1230 1231 default: 1232 return false 1233 } 1234 } 1235 // Iterator still in progress, wait for either a data or an error event 1236 select { 1237 case log := <-it.logs: 1238 it.Event = new(ERC20Approval) 1239 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1240 it.fail = err 1241 return false 1242 } 1243 it.Event.Raw = log 1244 return true 1245 1246 case err := <-it.sub.Err(): 1247 it.done = true 1248 it.fail = err 1249 return it.Next() 1250 } 1251 } 1252 1253 // Error returns any retrieval or parsing error occurred during filtering. 1254 func (it *ERC20ApprovalIterator) Error() error { 1255 return it.fail 1256 } 1257 1258 // Close terminates the iteration process, releasing any pending underlying 1259 // resources. 1260 func (it *ERC20ApprovalIterator) Close() error { 1261 it.sub.Unsubscribe() 1262 return nil 1263 } 1264 1265 // ERC20Approval represents a Approval event raised by the ERC20 contract. 1266 type ERC20Approval struct { 1267 Owner common.Address 1268 Spender common.Address 1269 Value *big.Int 1270 Raw types.Log // Blockchain specific contextual infos 1271 } 1272 1273 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 1274 // 1275 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 1276 func (_ERC20 *ERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20ApprovalIterator, error) { 1277 1278 var ownerRule []interface{} 1279 for _, ownerItem := range owner { 1280 ownerRule = append(ownerRule, ownerItem) 1281 } 1282 var spenderRule []interface{} 1283 for _, spenderItem := range spender { 1284 spenderRule = append(spenderRule, spenderItem) 1285 } 1286 1287 logs, sub, err := _ERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 1288 if err != nil { 1289 return nil, err 1290 } 1291 return &ERC20ApprovalIterator{contract: _ERC20.contract, event: "Approval", logs: logs, sub: sub}, nil 1292 } 1293 1294 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 1295 // 1296 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 1297 func (_ERC20 *ERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 1298 1299 var ownerRule []interface{} 1300 for _, ownerItem := range owner { 1301 ownerRule = append(ownerRule, ownerItem) 1302 } 1303 var spenderRule []interface{} 1304 for _, spenderItem := range spender { 1305 spenderRule = append(spenderRule, spenderItem) 1306 } 1307 1308 logs, sub, err := _ERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 1309 if err != nil { 1310 return nil, err 1311 } 1312 return event.NewSubscription(func(quit <-chan struct{}) error { 1313 defer sub.Unsubscribe() 1314 for { 1315 select { 1316 case log := <-logs: 1317 // New log arrived, parse the event and forward to the user 1318 event := new(ERC20Approval) 1319 if err := _ERC20.contract.UnpackLog(event, "Approval", log); err != nil { 1320 return err 1321 } 1322 event.Raw = log 1323 1324 select { 1325 case sink <- event: 1326 case err := <-sub.Err(): 1327 return err 1328 case <-quit: 1329 return nil 1330 } 1331 case err := <-sub.Err(): 1332 return err 1333 case <-quit: 1334 return nil 1335 } 1336 } 1337 }), nil 1338 } 1339 1340 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 1341 // 1342 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 1343 func (_ERC20 *ERC20Filterer) ParseApproval(log types.Log) (*ERC20Approval, error) { 1344 event := new(ERC20Approval) 1345 if err := _ERC20.contract.UnpackLog(event, "Approval", log); err != nil { 1346 return nil, err 1347 } 1348 return event, nil 1349 } 1350 1351 // 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. 1352 type ERC20TransferIterator struct { 1353 Event *ERC20Transfer // Event containing the contract specifics and raw log 1354 1355 contract *bind.BoundContract // Generic contract to use for unpacking event data 1356 event string // Event name to use for unpacking event data 1357 1358 logs chan types.Log // Log channel receiving the found contract events 1359 sub ethereum.Subscription // Subscription for errors, completion and termination 1360 done bool // Whether the subscription completed delivering logs 1361 fail error // Occurred error to stop iteration 1362 } 1363 1364 // Next advances the iterator to the subsequent event, returning whether there 1365 // are any more events found. In case of a retrieval or parsing error, false is 1366 // returned and Error() can be queried for the exact failure. 1367 func (it *ERC20TransferIterator) Next() bool { 1368 // If the iterator failed, stop iterating 1369 if it.fail != nil { 1370 return false 1371 } 1372 // If the iterator completed, deliver directly whatever's available 1373 if it.done { 1374 select { 1375 case log := <-it.logs: 1376 it.Event = new(ERC20Transfer) 1377 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1378 it.fail = err 1379 return false 1380 } 1381 it.Event.Raw = log 1382 return true 1383 1384 default: 1385 return false 1386 } 1387 } 1388 // Iterator still in progress, wait for either a data or an error event 1389 select { 1390 case log := <-it.logs: 1391 it.Event = new(ERC20Transfer) 1392 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1393 it.fail = err 1394 return false 1395 } 1396 it.Event.Raw = log 1397 return true 1398 1399 case err := <-it.sub.Err(): 1400 it.done = true 1401 it.fail = err 1402 return it.Next() 1403 } 1404 } 1405 1406 // Error returns any retrieval or parsing error occurred during filtering. 1407 func (it *ERC20TransferIterator) Error() error { 1408 return it.fail 1409 } 1410 1411 // Close terminates the iteration process, releasing any pending underlying 1412 // resources. 1413 func (it *ERC20TransferIterator) Close() error { 1414 it.sub.Unsubscribe() 1415 return nil 1416 } 1417 1418 // ERC20Transfer represents a Transfer event raised by the ERC20 contract. 1419 type ERC20Transfer struct { 1420 From common.Address 1421 To common.Address 1422 Value *big.Int 1423 Raw types.Log // Blockchain specific contextual infos 1424 } 1425 1426 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 1427 // 1428 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 1429 func (_ERC20 *ERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20TransferIterator, error) { 1430 1431 var fromRule []interface{} 1432 for _, fromItem := range from { 1433 fromRule = append(fromRule, fromItem) 1434 } 1435 var toRule []interface{} 1436 for _, toItem := range to { 1437 toRule = append(toRule, toItem) 1438 } 1439 1440 logs, sub, err := _ERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 1441 if err != nil { 1442 return nil, err 1443 } 1444 return &ERC20TransferIterator{contract: _ERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil 1445 } 1446 1447 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 1448 // 1449 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 1450 func (_ERC20 *ERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { 1451 1452 var fromRule []interface{} 1453 for _, fromItem := range from { 1454 fromRule = append(fromRule, fromItem) 1455 } 1456 var toRule []interface{} 1457 for _, toItem := range to { 1458 toRule = append(toRule, toItem) 1459 } 1460 1461 logs, sub, err := _ERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 1462 if err != nil { 1463 return nil, err 1464 } 1465 return event.NewSubscription(func(quit <-chan struct{}) error { 1466 defer sub.Unsubscribe() 1467 for { 1468 select { 1469 case log := <-logs: 1470 // New log arrived, parse the event and forward to the user 1471 event := new(ERC20Transfer) 1472 if err := _ERC20.contract.UnpackLog(event, "Transfer", log); err != nil { 1473 return err 1474 } 1475 event.Raw = log 1476 1477 select { 1478 case sink <- event: 1479 case err := <-sub.Err(): 1480 return err 1481 case <-quit: 1482 return nil 1483 } 1484 case err := <-sub.Err(): 1485 return err 1486 case <-quit: 1487 return nil 1488 } 1489 } 1490 }), nil 1491 } 1492 1493 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 1494 // 1495 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 1496 func (_ERC20 *ERC20Filterer) ParseTransfer(log types.Log) (*ERC20Transfer, error) { 1497 event := new(ERC20Transfer) 1498 if err := _ERC20.contract.UnpackLog(event, "Transfer", log); err != nil { 1499 return nil, err 1500 } 1501 return event, nil 1502 } 1503 1504 // ERC20DetailedABI is the input ABI used to generate the binding from. 1505 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\"}]" 1506 1507 // ERC20DetailedFuncSigs maps the 4-byte function signature to its string representation. 1508 var ERC20DetailedFuncSigs = map[string]string{ 1509 "dd62ed3e": "allowance(address,address)", 1510 "095ea7b3": "approve(address,uint256)", 1511 "70a08231": "balanceOf(address)", 1512 "313ce567": "decimals()", 1513 "06fdde03": "name()", 1514 "95d89b41": "symbol()", 1515 "18160ddd": "totalSupply()", 1516 "a9059cbb": "transfer(address,uint256)", 1517 "23b872dd": "transferFrom(address,address,uint256)", 1518 } 1519 1520 // ERC20Detailed is an auto generated Go binding around an Ethereum contract. 1521 type ERC20Detailed struct { 1522 ERC20DetailedCaller // Read-only binding to the contract 1523 ERC20DetailedTransactor // Write-only binding to the contract 1524 ERC20DetailedFilterer // Log filterer for contract events 1525 } 1526 1527 // ERC20DetailedCaller is an auto generated read-only Go binding around an Ethereum contract. 1528 type ERC20DetailedCaller struct { 1529 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1530 } 1531 1532 // ERC20DetailedTransactor is an auto generated write-only Go binding around an Ethereum contract. 1533 type ERC20DetailedTransactor struct { 1534 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1535 } 1536 1537 // ERC20DetailedFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 1538 type ERC20DetailedFilterer struct { 1539 contract *bind.BoundContract // Generic contract wrapper for the low level calls 1540 } 1541 1542 // ERC20DetailedSession is an auto generated Go binding around an Ethereum contract, 1543 // with pre-set call and transact options. 1544 type ERC20DetailedSession struct { 1545 Contract *ERC20Detailed // Generic contract binding to set the session for 1546 CallOpts bind.CallOpts // Call options to use throughout this session 1547 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1548 } 1549 1550 // ERC20DetailedCallerSession is an auto generated read-only Go binding around an Ethereum contract, 1551 // with pre-set call options. 1552 type ERC20DetailedCallerSession struct { 1553 Contract *ERC20DetailedCaller // Generic contract caller binding to set the session for 1554 CallOpts bind.CallOpts // Call options to use throughout this session 1555 } 1556 1557 // ERC20DetailedTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 1558 // with pre-set transact options. 1559 type ERC20DetailedTransactorSession struct { 1560 Contract *ERC20DetailedTransactor // Generic contract transactor binding to set the session for 1561 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 1562 } 1563 1564 // ERC20DetailedRaw is an auto generated low-level Go binding around an Ethereum contract. 1565 type ERC20DetailedRaw struct { 1566 Contract *ERC20Detailed // Generic contract binding to access the raw methods on 1567 } 1568 1569 // ERC20DetailedCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 1570 type ERC20DetailedCallerRaw struct { 1571 Contract *ERC20DetailedCaller // Generic read-only contract binding to access the raw methods on 1572 } 1573 1574 // ERC20DetailedTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 1575 type ERC20DetailedTransactorRaw struct { 1576 Contract *ERC20DetailedTransactor // Generic write-only contract binding to access the raw methods on 1577 } 1578 1579 // NewERC20Detailed creates a new instance of ERC20Detailed, bound to a specific deployed contract. 1580 func NewERC20Detailed(address common.Address, backend bind.ContractBackend) (*ERC20Detailed, error) { 1581 contract, err := bindERC20Detailed(address, backend, backend, backend) 1582 if err != nil { 1583 return nil, err 1584 } 1585 return &ERC20Detailed{ERC20DetailedCaller: ERC20DetailedCaller{contract: contract}, ERC20DetailedTransactor: ERC20DetailedTransactor{contract: contract}, ERC20DetailedFilterer: ERC20DetailedFilterer{contract: contract}}, nil 1586 } 1587 1588 // NewERC20DetailedCaller creates a new read-only instance of ERC20Detailed, bound to a specific deployed contract. 1589 func NewERC20DetailedCaller(address common.Address, caller bind.ContractCaller) (*ERC20DetailedCaller, error) { 1590 contract, err := bindERC20Detailed(address, caller, nil, nil) 1591 if err != nil { 1592 return nil, err 1593 } 1594 return &ERC20DetailedCaller{contract: contract}, nil 1595 } 1596 1597 // NewERC20DetailedTransactor creates a new write-only instance of ERC20Detailed, bound to a specific deployed contract. 1598 func NewERC20DetailedTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20DetailedTransactor, error) { 1599 contract, err := bindERC20Detailed(address, nil, transactor, nil) 1600 if err != nil { 1601 return nil, err 1602 } 1603 return &ERC20DetailedTransactor{contract: contract}, nil 1604 } 1605 1606 // NewERC20DetailedFilterer creates a new log filterer instance of ERC20Detailed, bound to a specific deployed contract. 1607 func NewERC20DetailedFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20DetailedFilterer, error) { 1608 contract, err := bindERC20Detailed(address, nil, nil, filterer) 1609 if err != nil { 1610 return nil, err 1611 } 1612 return &ERC20DetailedFilterer{contract: contract}, nil 1613 } 1614 1615 // bindERC20Detailed binds a generic wrapper to an already deployed contract. 1616 func bindERC20Detailed(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 1617 parsed, err := abi.JSON(strings.NewReader(ERC20DetailedABI)) 1618 if err != nil { 1619 return nil, err 1620 } 1621 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 1622 } 1623 1624 // Call invokes the (constant) contract method with params as input values and 1625 // sets the output to result. The result type might be a single field for simple 1626 // returns, a slice of interfaces for anonymous returns and a struct for named 1627 // returns. 1628 func (_ERC20Detailed *ERC20DetailedRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 1629 return _ERC20Detailed.Contract.ERC20DetailedCaller.contract.Call(opts, result, method, params...) 1630 } 1631 1632 // Transfer initiates a plain transaction to move funds to the contract, calling 1633 // its default method if one is available. 1634 func (_ERC20Detailed *ERC20DetailedRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1635 return _ERC20Detailed.Contract.ERC20DetailedTransactor.contract.Transfer(opts) 1636 } 1637 1638 // Transact invokes the (paid) contract method with params as input values. 1639 func (_ERC20Detailed *ERC20DetailedRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1640 return _ERC20Detailed.Contract.ERC20DetailedTransactor.contract.Transact(opts, method, params...) 1641 } 1642 1643 // Call invokes the (constant) contract method with params as input values and 1644 // sets the output to result. The result type might be a single field for simple 1645 // returns, a slice of interfaces for anonymous returns and a struct for named 1646 // returns. 1647 func (_ERC20Detailed *ERC20DetailedCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 1648 return _ERC20Detailed.Contract.contract.Call(opts, result, method, params...) 1649 } 1650 1651 // Transfer initiates a plain transaction to move funds to the contract, calling 1652 // its default method if one is available. 1653 func (_ERC20Detailed *ERC20DetailedTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 1654 return _ERC20Detailed.Contract.contract.Transfer(opts) 1655 } 1656 1657 // Transact invokes the (paid) contract method with params as input values. 1658 func (_ERC20Detailed *ERC20DetailedTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 1659 return _ERC20Detailed.Contract.contract.Transact(opts, method, params...) 1660 } 1661 1662 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 1663 // 1664 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 1665 func (_ERC20Detailed *ERC20DetailedCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 1666 var ( 1667 ret0 = new(*big.Int) 1668 ) 1669 out := ret0 1670 err := _ERC20Detailed.contract.Call(opts, out, "allowance", owner, spender) 1671 return *ret0, err 1672 } 1673 1674 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 1675 // 1676 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 1677 func (_ERC20Detailed *ERC20DetailedSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 1678 return _ERC20Detailed.Contract.Allowance(&_ERC20Detailed.CallOpts, owner, spender) 1679 } 1680 1681 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 1682 // 1683 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 1684 func (_ERC20Detailed *ERC20DetailedCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 1685 return _ERC20Detailed.Contract.Allowance(&_ERC20Detailed.CallOpts, owner, spender) 1686 } 1687 1688 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1689 // 1690 // Solidity: function balanceOf(address account) constant returns(uint256) 1691 func (_ERC20Detailed *ERC20DetailedCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 1692 var ( 1693 ret0 = new(*big.Int) 1694 ) 1695 out := ret0 1696 err := _ERC20Detailed.contract.Call(opts, out, "balanceOf", account) 1697 return *ret0, err 1698 } 1699 1700 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1701 // 1702 // Solidity: function balanceOf(address account) constant returns(uint256) 1703 func (_ERC20Detailed *ERC20DetailedSession) BalanceOf(account common.Address) (*big.Int, error) { 1704 return _ERC20Detailed.Contract.BalanceOf(&_ERC20Detailed.CallOpts, account) 1705 } 1706 1707 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 1708 // 1709 // Solidity: function balanceOf(address account) constant returns(uint256) 1710 func (_ERC20Detailed *ERC20DetailedCallerSession) BalanceOf(account common.Address) (*big.Int, error) { 1711 return _ERC20Detailed.Contract.BalanceOf(&_ERC20Detailed.CallOpts, account) 1712 } 1713 1714 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 1715 // 1716 // Solidity: function decimals() constant returns(uint8) 1717 func (_ERC20Detailed *ERC20DetailedCaller) Decimals(opts *bind.CallOpts) (uint8, error) { 1718 var ( 1719 ret0 = new(uint8) 1720 ) 1721 out := ret0 1722 err := _ERC20Detailed.contract.Call(opts, out, "decimals") 1723 return *ret0, err 1724 } 1725 1726 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 1727 // 1728 // Solidity: function decimals() constant returns(uint8) 1729 func (_ERC20Detailed *ERC20DetailedSession) Decimals() (uint8, error) { 1730 return _ERC20Detailed.Contract.Decimals(&_ERC20Detailed.CallOpts) 1731 } 1732 1733 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 1734 // 1735 // Solidity: function decimals() constant returns(uint8) 1736 func (_ERC20Detailed *ERC20DetailedCallerSession) Decimals() (uint8, error) { 1737 return _ERC20Detailed.Contract.Decimals(&_ERC20Detailed.CallOpts) 1738 } 1739 1740 // Name is a free data retrieval call binding the contract method 0x06fdde03. 1741 // 1742 // Solidity: function name() constant returns(string) 1743 func (_ERC20Detailed *ERC20DetailedCaller) Name(opts *bind.CallOpts) (string, error) { 1744 var ( 1745 ret0 = new(string) 1746 ) 1747 out := ret0 1748 err := _ERC20Detailed.contract.Call(opts, out, "name") 1749 return *ret0, err 1750 } 1751 1752 // Name is a free data retrieval call binding the contract method 0x06fdde03. 1753 // 1754 // Solidity: function name() constant returns(string) 1755 func (_ERC20Detailed *ERC20DetailedSession) Name() (string, error) { 1756 return _ERC20Detailed.Contract.Name(&_ERC20Detailed.CallOpts) 1757 } 1758 1759 // Name is a free data retrieval call binding the contract method 0x06fdde03. 1760 // 1761 // Solidity: function name() constant returns(string) 1762 func (_ERC20Detailed *ERC20DetailedCallerSession) Name() (string, error) { 1763 return _ERC20Detailed.Contract.Name(&_ERC20Detailed.CallOpts) 1764 } 1765 1766 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 1767 // 1768 // Solidity: function symbol() constant returns(string) 1769 func (_ERC20Detailed *ERC20DetailedCaller) Symbol(opts *bind.CallOpts) (string, error) { 1770 var ( 1771 ret0 = new(string) 1772 ) 1773 out := ret0 1774 err := _ERC20Detailed.contract.Call(opts, out, "symbol") 1775 return *ret0, err 1776 } 1777 1778 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 1779 // 1780 // Solidity: function symbol() constant returns(string) 1781 func (_ERC20Detailed *ERC20DetailedSession) Symbol() (string, error) { 1782 return _ERC20Detailed.Contract.Symbol(&_ERC20Detailed.CallOpts) 1783 } 1784 1785 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 1786 // 1787 // Solidity: function symbol() constant returns(string) 1788 func (_ERC20Detailed *ERC20DetailedCallerSession) Symbol() (string, error) { 1789 return _ERC20Detailed.Contract.Symbol(&_ERC20Detailed.CallOpts) 1790 } 1791 1792 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1793 // 1794 // Solidity: function totalSupply() constant returns(uint256) 1795 func (_ERC20Detailed *ERC20DetailedCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 1796 var ( 1797 ret0 = new(*big.Int) 1798 ) 1799 out := ret0 1800 err := _ERC20Detailed.contract.Call(opts, out, "totalSupply") 1801 return *ret0, err 1802 } 1803 1804 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1805 // 1806 // Solidity: function totalSupply() constant returns(uint256) 1807 func (_ERC20Detailed *ERC20DetailedSession) TotalSupply() (*big.Int, error) { 1808 return _ERC20Detailed.Contract.TotalSupply(&_ERC20Detailed.CallOpts) 1809 } 1810 1811 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 1812 // 1813 // Solidity: function totalSupply() constant returns(uint256) 1814 func (_ERC20Detailed *ERC20DetailedCallerSession) TotalSupply() (*big.Int, error) { 1815 return _ERC20Detailed.Contract.TotalSupply(&_ERC20Detailed.CallOpts) 1816 } 1817 1818 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 1819 // 1820 // Solidity: function approve(address spender, uint256 amount) returns(bool) 1821 func (_ERC20Detailed *ERC20DetailedTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 1822 return _ERC20Detailed.contract.Transact(opts, "approve", spender, amount) 1823 } 1824 1825 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 1826 // 1827 // Solidity: function approve(address spender, uint256 amount) returns(bool) 1828 func (_ERC20Detailed *ERC20DetailedSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 1829 return _ERC20Detailed.Contract.Approve(&_ERC20Detailed.TransactOpts, spender, amount) 1830 } 1831 1832 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 1833 // 1834 // Solidity: function approve(address spender, uint256 amount) returns(bool) 1835 func (_ERC20Detailed *ERC20DetailedTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 1836 return _ERC20Detailed.Contract.Approve(&_ERC20Detailed.TransactOpts, spender, amount) 1837 } 1838 1839 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1840 // 1841 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 1842 func (_ERC20Detailed *ERC20DetailedTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1843 return _ERC20Detailed.contract.Transact(opts, "transfer", recipient, amount) 1844 } 1845 1846 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1847 // 1848 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 1849 func (_ERC20Detailed *ERC20DetailedSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1850 return _ERC20Detailed.Contract.Transfer(&_ERC20Detailed.TransactOpts, recipient, amount) 1851 } 1852 1853 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 1854 // 1855 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 1856 func (_ERC20Detailed *ERC20DetailedTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1857 return _ERC20Detailed.Contract.Transfer(&_ERC20Detailed.TransactOpts, recipient, amount) 1858 } 1859 1860 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 1861 // 1862 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 1863 func (_ERC20Detailed *ERC20DetailedTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1864 return _ERC20Detailed.contract.Transact(opts, "transferFrom", sender, recipient, amount) 1865 } 1866 1867 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 1868 // 1869 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 1870 func (_ERC20Detailed *ERC20DetailedSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1871 return _ERC20Detailed.Contract.TransferFrom(&_ERC20Detailed.TransactOpts, sender, recipient, amount) 1872 } 1873 1874 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 1875 // 1876 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 1877 func (_ERC20Detailed *ERC20DetailedTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 1878 return _ERC20Detailed.Contract.TransferFrom(&_ERC20Detailed.TransactOpts, sender, recipient, amount) 1879 } 1880 1881 // 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. 1882 type ERC20DetailedApprovalIterator struct { 1883 Event *ERC20DetailedApproval // Event containing the contract specifics and raw log 1884 1885 contract *bind.BoundContract // Generic contract to use for unpacking event data 1886 event string // Event name to use for unpacking event data 1887 1888 logs chan types.Log // Log channel receiving the found contract events 1889 sub ethereum.Subscription // Subscription for errors, completion and termination 1890 done bool // Whether the subscription completed delivering logs 1891 fail error // Occurred error to stop iteration 1892 } 1893 1894 // Next advances the iterator to the subsequent event, returning whether there 1895 // are any more events found. In case of a retrieval or parsing error, false is 1896 // returned and Error() can be queried for the exact failure. 1897 func (it *ERC20DetailedApprovalIterator) Next() bool { 1898 // If the iterator failed, stop iterating 1899 if it.fail != nil { 1900 return false 1901 } 1902 // If the iterator completed, deliver directly whatever's available 1903 if it.done { 1904 select { 1905 case log := <-it.logs: 1906 it.Event = new(ERC20DetailedApproval) 1907 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1908 it.fail = err 1909 return false 1910 } 1911 it.Event.Raw = log 1912 return true 1913 1914 default: 1915 return false 1916 } 1917 } 1918 // Iterator still in progress, wait for either a data or an error event 1919 select { 1920 case log := <-it.logs: 1921 it.Event = new(ERC20DetailedApproval) 1922 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 1923 it.fail = err 1924 return false 1925 } 1926 it.Event.Raw = log 1927 return true 1928 1929 case err := <-it.sub.Err(): 1930 it.done = true 1931 it.fail = err 1932 return it.Next() 1933 } 1934 } 1935 1936 // Error returns any retrieval or parsing error occurred during filtering. 1937 func (it *ERC20DetailedApprovalIterator) Error() error { 1938 return it.fail 1939 } 1940 1941 // Close terminates the iteration process, releasing any pending underlying 1942 // resources. 1943 func (it *ERC20DetailedApprovalIterator) Close() error { 1944 it.sub.Unsubscribe() 1945 return nil 1946 } 1947 1948 // ERC20DetailedApproval represents a Approval event raised by the ERC20Detailed contract. 1949 type ERC20DetailedApproval struct { 1950 Owner common.Address 1951 Spender common.Address 1952 Value *big.Int 1953 Raw types.Log // Blockchain specific contextual infos 1954 } 1955 1956 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 1957 // 1958 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 1959 func (_ERC20Detailed *ERC20DetailedFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20DetailedApprovalIterator, error) { 1960 1961 var ownerRule []interface{} 1962 for _, ownerItem := range owner { 1963 ownerRule = append(ownerRule, ownerItem) 1964 } 1965 var spenderRule []interface{} 1966 for _, spenderItem := range spender { 1967 spenderRule = append(spenderRule, spenderItem) 1968 } 1969 1970 logs, sub, err := _ERC20Detailed.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 1971 if err != nil { 1972 return nil, err 1973 } 1974 return &ERC20DetailedApprovalIterator{contract: _ERC20Detailed.contract, event: "Approval", logs: logs, sub: sub}, nil 1975 } 1976 1977 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 1978 // 1979 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 1980 func (_ERC20Detailed *ERC20DetailedFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20DetailedApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 1981 1982 var ownerRule []interface{} 1983 for _, ownerItem := range owner { 1984 ownerRule = append(ownerRule, ownerItem) 1985 } 1986 var spenderRule []interface{} 1987 for _, spenderItem := range spender { 1988 spenderRule = append(spenderRule, spenderItem) 1989 } 1990 1991 logs, sub, err := _ERC20Detailed.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 1992 if err != nil { 1993 return nil, err 1994 } 1995 return event.NewSubscription(func(quit <-chan struct{}) error { 1996 defer sub.Unsubscribe() 1997 for { 1998 select { 1999 case log := <-logs: 2000 // New log arrived, parse the event and forward to the user 2001 event := new(ERC20DetailedApproval) 2002 if err := _ERC20Detailed.contract.UnpackLog(event, "Approval", log); err != nil { 2003 return err 2004 } 2005 event.Raw = log 2006 2007 select { 2008 case sink <- event: 2009 case err := <-sub.Err(): 2010 return err 2011 case <-quit: 2012 return nil 2013 } 2014 case err := <-sub.Err(): 2015 return err 2016 case <-quit: 2017 return nil 2018 } 2019 } 2020 }), nil 2021 } 2022 2023 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 2024 // 2025 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 2026 func (_ERC20Detailed *ERC20DetailedFilterer) ParseApproval(log types.Log) (*ERC20DetailedApproval, error) { 2027 event := new(ERC20DetailedApproval) 2028 if err := _ERC20Detailed.contract.UnpackLog(event, "Approval", log); err != nil { 2029 return nil, err 2030 } 2031 return event, nil 2032 } 2033 2034 // 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. 2035 type ERC20DetailedTransferIterator struct { 2036 Event *ERC20DetailedTransfer // Event containing the contract specifics and raw log 2037 2038 contract *bind.BoundContract // Generic contract to use for unpacking event data 2039 event string // Event name to use for unpacking event data 2040 2041 logs chan types.Log // Log channel receiving the found contract events 2042 sub ethereum.Subscription // Subscription for errors, completion and termination 2043 done bool // Whether the subscription completed delivering logs 2044 fail error // Occurred error to stop iteration 2045 } 2046 2047 // Next advances the iterator to the subsequent event, returning whether there 2048 // are any more events found. In case of a retrieval or parsing error, false is 2049 // returned and Error() can be queried for the exact failure. 2050 func (it *ERC20DetailedTransferIterator) Next() bool { 2051 // If the iterator failed, stop iterating 2052 if it.fail != nil { 2053 return false 2054 } 2055 // If the iterator completed, deliver directly whatever's available 2056 if it.done { 2057 select { 2058 case log := <-it.logs: 2059 it.Event = new(ERC20DetailedTransfer) 2060 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2061 it.fail = err 2062 return false 2063 } 2064 it.Event.Raw = log 2065 return true 2066 2067 default: 2068 return false 2069 } 2070 } 2071 // Iterator still in progress, wait for either a data or an error event 2072 select { 2073 case log := <-it.logs: 2074 it.Event = new(ERC20DetailedTransfer) 2075 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2076 it.fail = err 2077 return false 2078 } 2079 it.Event.Raw = log 2080 return true 2081 2082 case err := <-it.sub.Err(): 2083 it.done = true 2084 it.fail = err 2085 return it.Next() 2086 } 2087 } 2088 2089 // Error returns any retrieval or parsing error occurred during filtering. 2090 func (it *ERC20DetailedTransferIterator) Error() error { 2091 return it.fail 2092 } 2093 2094 // Close terminates the iteration process, releasing any pending underlying 2095 // resources. 2096 func (it *ERC20DetailedTransferIterator) Close() error { 2097 it.sub.Unsubscribe() 2098 return nil 2099 } 2100 2101 // ERC20DetailedTransfer represents a Transfer event raised by the ERC20Detailed contract. 2102 type ERC20DetailedTransfer struct { 2103 From common.Address 2104 To common.Address 2105 Value *big.Int 2106 Raw types.Log // Blockchain specific contextual infos 2107 } 2108 2109 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 2110 // 2111 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 2112 func (_ERC20Detailed *ERC20DetailedFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20DetailedTransferIterator, error) { 2113 2114 var fromRule []interface{} 2115 for _, fromItem := range from { 2116 fromRule = append(fromRule, fromItem) 2117 } 2118 var toRule []interface{} 2119 for _, toItem := range to { 2120 toRule = append(toRule, toItem) 2121 } 2122 2123 logs, sub, err := _ERC20Detailed.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 2124 if err != nil { 2125 return nil, err 2126 } 2127 return &ERC20DetailedTransferIterator{contract: _ERC20Detailed.contract, event: "Transfer", logs: logs, sub: sub}, nil 2128 } 2129 2130 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 2131 // 2132 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 2133 func (_ERC20Detailed *ERC20DetailedFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20DetailedTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 2134 2135 var fromRule []interface{} 2136 for _, fromItem := range from { 2137 fromRule = append(fromRule, fromItem) 2138 } 2139 var toRule []interface{} 2140 for _, toItem := range to { 2141 toRule = append(toRule, toItem) 2142 } 2143 2144 logs, sub, err := _ERC20Detailed.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 2145 if err != nil { 2146 return nil, err 2147 } 2148 return event.NewSubscription(func(quit <-chan struct{}) error { 2149 defer sub.Unsubscribe() 2150 for { 2151 select { 2152 case log := <-logs: 2153 // New log arrived, parse the event and forward to the user 2154 event := new(ERC20DetailedTransfer) 2155 if err := _ERC20Detailed.contract.UnpackLog(event, "Transfer", log); err != nil { 2156 return err 2157 } 2158 event.Raw = log 2159 2160 select { 2161 case sink <- event: 2162 case err := <-sub.Err(): 2163 return err 2164 case <-quit: 2165 return nil 2166 } 2167 case err := <-sub.Err(): 2168 return err 2169 case <-quit: 2170 return nil 2171 } 2172 } 2173 }), nil 2174 } 2175 2176 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 2177 // 2178 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 2179 func (_ERC20Detailed *ERC20DetailedFilterer) ParseTransfer(log types.Log) (*ERC20DetailedTransfer, error) { 2180 event := new(ERC20DetailedTransfer) 2181 if err := _ERC20Detailed.contract.UnpackLog(event, "Transfer", log); err != nil { 2182 return nil, err 2183 } 2184 return event, nil 2185 } 2186 2187 // ERC20MintableABI is the input ABI used to generate the binding from. 2188 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\"}]" 2189 2190 // ERC20MintableFuncSigs maps the 4-byte function signature to its string representation. 2191 var ERC20MintableFuncSigs = map[string]string{ 2192 "983b2d56": "addMinter(address)", 2193 "dd62ed3e": "allowance(address,address)", 2194 "095ea7b3": "approve(address,uint256)", 2195 "70a08231": "balanceOf(address)", 2196 "a457c2d7": "decreaseAllowance(address,uint256)", 2197 "39509351": "increaseAllowance(address,uint256)", 2198 "aa271e1a": "isMinter(address)", 2199 "40c10f19": "mint(address,uint256)", 2200 "98650275": "renounceMinter()", 2201 "18160ddd": "totalSupply()", 2202 "a9059cbb": "transfer(address,uint256)", 2203 "23b872dd": "transferFrom(address,address,uint256)", 2204 } 2205 2206 // ERC20MintableBin is the compiled bytecode used for deploying new contracts. 2207 var ERC20MintableBin = "0x60806040526100266100186001600160e01b0361002b16565b6001600160e01b0361002f16565b6101a3565b3390565b61004781600361007e60201b610a6e1790919060201c565b6040516001600160a01b038216907f6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f690600090a250565b61009182826001600160e01b0361012216565b156100fd57604080517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601f60248201527f526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500604482015290519081900360640190fd5b6001600160a01b0316600090815260209190915260409020805460ff19166001179055565b60006001600160a01b038216610183576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401808060200182810382526022815260200180610eb16022913960400191505060405180910390fd5b506001600160a01b03166000908152602091909152604090205460ff1690565b610cff806101b26000396000f3fe608060405234801561001057600080fd5b50600436106100b45760003560e01c8063983b2d5611610071578063983b2d56146101c757806398650275146101ef578063a457c2d7146101f7578063a9059cbb14610223578063aa271e1a1461024f578063dd62ed3e14610275576100b4565b8063095ea7b3146100b957806318160ddd146100f957806323b872dd14610113578063395093511461014957806340c10f191461017557806370a08231146101a1575b600080fd5b6100e5600480360360408110156100cf57600080fd5b506001600160a01b0381351690602001356102a3565b604080519115158252519081900360200190f35b6101016102c0565b60408051918252519081900360200190f35b6100e56004803603606081101561012957600080fd5b506001600160a01b038135811691602081013590911690604001356102c6565b6100e56004803603604081101561015f57600080fd5b506001600160a01b038135169060200135610353565b6100e56004803603604081101561018b57600080fd5b506001600160a01b0381351690602001356103a7565b610101600480360360208110156101b757600080fd5b50356001600160a01b03166103fe565b6101ed600480360360208110156101dd57600080fd5b50356001600160a01b0316610419565b005b6101ed61046b565b6100e56004803603604081101561020d57600080fd5b506001600160a01b03813516906020013561047d565b6100e56004803603604081101561023957600080fd5b506001600160a01b0381351690602001356104eb565b6100e56004803603602081101561026557600080fd5b50356001600160a01b03166104ff565b6101016004803603604081101561028b57600080fd5b506001600160a01b0381358116916020013516610518565b60006102b76102b0610543565b8484610547565b50600192915050565b60025490565b60006102d3848484610633565b610349846102df610543565b61034485604051806060016040528060288152602001610c13602891396001600160a01b038a1660009081526001602052604081209061031d610543565b6001600160a01b03168152602081019190915260400160002054919063ffffffff61078f16565b610547565b5060019392505050565b60006102b7610360610543565b846103448560016000610371610543565b6001600160a01b03908116825260208083019390935260409182016000908120918c16815292529020549063ffffffff61082616565b60006103b96103b4610543565b6104ff565b6103f45760405162461bcd60e51b8152600401808060200182810382526030815260200180610bc26030913960400191505060405180910390fd5b6102b78383610887565b6001600160a01b031660009081526020819052604090205490565b6104246103b4610543565b61045f5760405162461bcd60e51b8152600401808060200182810382526030815260200180610bc26030913960400191505060405180910390fd5b61046881610977565b50565b61047b610476610543565b6109bf565b565b60006102b761048a610543565b8461034485604051806060016040528060258152602001610ca660259139600160006104b4610543565b6001600160a01b03908116825260208083019390935260409182016000908120918d1681529252902054919063ffffffff61078f16565b60006102b76104f8610543565b8484610633565b600061051260038363ffffffff610a0716565b92915050565b6001600160a01b03918216600090815260016020908152604080832093909416825291909152205490565b3390565b6001600160a01b03831661058c5760405162461bcd60e51b8152600401808060200182810382526024815260200180610c826024913960400191505060405180910390fd5b6001600160a01b0382166105d15760405162461bcd60e51b8152600401808060200182810382526022815260200180610b7a6022913960400191505060405180910390fd5b6001600160a01b03808416600081815260016020908152604080832094871680845294825291829020859055815185815291517f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b9259281900390910190a3505050565b6001600160a01b0383166106785760405162461bcd60e51b8152600401808060200182810382526025815260200180610c5d6025913960400191505060405180910390fd5b6001600160a01b0382166106bd5760405162461bcd60e51b8152600401808060200182810382526023815260200180610b576023913960400191505060405180910390fd5b61070081604051806060016040528060268152602001610b9c602691396001600160a01b038616600090815260208190526040902054919063ffffffff61078f16565b6001600160a01b038085166000908152602081905260408082209390935590841681522054610735908263ffffffff61082616565b6001600160a01b038084166000818152602081815260409182902094909455805185815290519193928716927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef92918290030190a3505050565b6000818484111561081e5760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b838110156107e35781810151838201526020016107cb565b50505050905090810190601f1680156108105780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b505050900390565b600082820183811015610880576040805162461bcd60e51b815260206004820152601b60248201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604482015290519081900360640190fd5b9392505050565b6001600160a01b0382166108e2576040805162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f206164647265737300604482015290519081900360640190fd5b6002546108f5908263ffffffff61082616565b6002556001600160a01b038216600090815260208190526040902054610921908263ffffffff61082616565b6001600160a01b0383166000818152602081815260408083209490945583518581529351929391927fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef9281900390910190a35050565b61098860038263ffffffff610a6e16565b6040516001600160a01b038216907f6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f690600090a250565b6109d060038263ffffffff610aef16565b6040516001600160a01b038216907fe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb6669290600090a250565b60006001600160a01b038216610a4e5760405162461bcd60e51b8152600401808060200182810382526022815260200180610c3b6022913960400191505060405180910390fd5b506001600160a01b03166000908152602091909152604090205460ff1690565b610a788282610a07565b15610aca576040805162461bcd60e51b815260206004820152601f60248201527f526f6c65733a206163636f756e7420616c72656164792068617320726f6c6500604482015290519081900360640190fd5b6001600160a01b0316600090815260209190915260409020805460ff19166001179055565b610af98282610a07565b610b345760405162461bcd60e51b8152600401808060200182810382526021815260200180610bf26021913960400191505060405180910390fd5b6001600160a01b0316600090815260209190915260409020805460ff1916905556fe45524332303a207472616e7366657220746f20746865207a65726f206164647265737345524332303a20617070726f766520746f20746865207a65726f206164647265737345524332303a207472616e7366657220616d6f756e7420657863656564732062616c616e63654d696e746572526f6c653a2063616c6c657220646f6573206e6f74206861766520746865204d696e74657220726f6c65526f6c65733a206163636f756e7420646f6573206e6f74206861766520726f6c6545524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e6365526f6c65733a206163636f756e7420697320746865207a65726f206164647265737345524332303a207472616e736665722066726f6d20746865207a65726f206164647265737345524332303a20617070726f76652066726f6d20746865207a65726f206164647265737345524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726fa265627a7a723158209bffbae26a8473ab446e60484fc8f37931f262c4c630ff4ea7ef2fd99a2a4ba364736f6c634300050c0032526f6c65733a206163636f756e7420697320746865207a65726f2061646472657373" 2208 2209 // DeployERC20Mintable deploys a new Ethereum contract, binding an instance of ERC20Mintable to it. 2210 func DeployERC20Mintable(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20Mintable, error) { 2211 parsed, err := abi.JSON(strings.NewReader(ERC20MintableABI)) 2212 if err != nil { 2213 return common.Address{}, nil, nil, err 2214 } 2215 2216 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20MintableBin), backend) 2217 if err != nil { 2218 return common.Address{}, nil, nil, err 2219 } 2220 return address, tx, &ERC20Mintable{ERC20MintableCaller: ERC20MintableCaller{contract: contract}, ERC20MintableTransactor: ERC20MintableTransactor{contract: contract}, ERC20MintableFilterer: ERC20MintableFilterer{contract: contract}}, nil 2221 } 2222 2223 // ERC20Mintable is an auto generated Go binding around an Ethereum contract. 2224 type ERC20Mintable struct { 2225 ERC20MintableCaller // Read-only binding to the contract 2226 ERC20MintableTransactor // Write-only binding to the contract 2227 ERC20MintableFilterer // Log filterer for contract events 2228 } 2229 2230 // ERC20MintableCaller is an auto generated read-only Go binding around an Ethereum contract. 2231 type ERC20MintableCaller struct { 2232 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2233 } 2234 2235 // ERC20MintableTransactor is an auto generated write-only Go binding around an Ethereum contract. 2236 type ERC20MintableTransactor struct { 2237 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2238 } 2239 2240 // ERC20MintableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 2241 type ERC20MintableFilterer struct { 2242 contract *bind.BoundContract // Generic contract wrapper for the low level calls 2243 } 2244 2245 // ERC20MintableSession is an auto generated Go binding around an Ethereum contract, 2246 // with pre-set call and transact options. 2247 type ERC20MintableSession struct { 2248 Contract *ERC20Mintable // Generic contract binding to set the session for 2249 CallOpts bind.CallOpts // Call options to use throughout this session 2250 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 2251 } 2252 2253 // ERC20MintableCallerSession is an auto generated read-only Go binding around an Ethereum contract, 2254 // with pre-set call options. 2255 type ERC20MintableCallerSession struct { 2256 Contract *ERC20MintableCaller // Generic contract caller binding to set the session for 2257 CallOpts bind.CallOpts // Call options to use throughout this session 2258 } 2259 2260 // ERC20MintableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 2261 // with pre-set transact options. 2262 type ERC20MintableTransactorSession struct { 2263 Contract *ERC20MintableTransactor // Generic contract transactor binding to set the session for 2264 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 2265 } 2266 2267 // ERC20MintableRaw is an auto generated low-level Go binding around an Ethereum contract. 2268 type ERC20MintableRaw struct { 2269 Contract *ERC20Mintable // Generic contract binding to access the raw methods on 2270 } 2271 2272 // ERC20MintableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 2273 type ERC20MintableCallerRaw struct { 2274 Contract *ERC20MintableCaller // Generic read-only contract binding to access the raw methods on 2275 } 2276 2277 // ERC20MintableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 2278 type ERC20MintableTransactorRaw struct { 2279 Contract *ERC20MintableTransactor // Generic write-only contract binding to access the raw methods on 2280 } 2281 2282 // NewERC20Mintable creates a new instance of ERC20Mintable, bound to a specific deployed contract. 2283 func NewERC20Mintable(address common.Address, backend bind.ContractBackend) (*ERC20Mintable, error) { 2284 contract, err := bindERC20Mintable(address, backend, backend, backend) 2285 if err != nil { 2286 return nil, err 2287 } 2288 return &ERC20Mintable{ERC20MintableCaller: ERC20MintableCaller{contract: contract}, ERC20MintableTransactor: ERC20MintableTransactor{contract: contract}, ERC20MintableFilterer: ERC20MintableFilterer{contract: contract}}, nil 2289 } 2290 2291 // NewERC20MintableCaller creates a new read-only instance of ERC20Mintable, bound to a specific deployed contract. 2292 func NewERC20MintableCaller(address common.Address, caller bind.ContractCaller) (*ERC20MintableCaller, error) { 2293 contract, err := bindERC20Mintable(address, caller, nil, nil) 2294 if err != nil { 2295 return nil, err 2296 } 2297 return &ERC20MintableCaller{contract: contract}, nil 2298 } 2299 2300 // NewERC20MintableTransactor creates a new write-only instance of ERC20Mintable, bound to a specific deployed contract. 2301 func NewERC20MintableTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20MintableTransactor, error) { 2302 contract, err := bindERC20Mintable(address, nil, transactor, nil) 2303 if err != nil { 2304 return nil, err 2305 } 2306 return &ERC20MintableTransactor{contract: contract}, nil 2307 } 2308 2309 // NewERC20MintableFilterer creates a new log filterer instance of ERC20Mintable, bound to a specific deployed contract. 2310 func NewERC20MintableFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20MintableFilterer, error) { 2311 contract, err := bindERC20Mintable(address, nil, nil, filterer) 2312 if err != nil { 2313 return nil, err 2314 } 2315 return &ERC20MintableFilterer{contract: contract}, nil 2316 } 2317 2318 // bindERC20Mintable binds a generic wrapper to an already deployed contract. 2319 func bindERC20Mintable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 2320 parsed, err := abi.JSON(strings.NewReader(ERC20MintableABI)) 2321 if err != nil { 2322 return nil, err 2323 } 2324 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 2325 } 2326 2327 // Call invokes the (constant) contract method with params as input values and 2328 // sets the output to result. The result type might be a single field for simple 2329 // returns, a slice of interfaces for anonymous returns and a struct for named 2330 // returns. 2331 func (_ERC20Mintable *ERC20MintableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 2332 return _ERC20Mintable.Contract.ERC20MintableCaller.contract.Call(opts, result, method, params...) 2333 } 2334 2335 // Transfer initiates a plain transaction to move funds to the contract, calling 2336 // its default method if one is available. 2337 func (_ERC20Mintable *ERC20MintableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 2338 return _ERC20Mintable.Contract.ERC20MintableTransactor.contract.Transfer(opts) 2339 } 2340 2341 // Transact invokes the (paid) contract method with params as input values. 2342 func (_ERC20Mintable *ERC20MintableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 2343 return _ERC20Mintable.Contract.ERC20MintableTransactor.contract.Transact(opts, method, params...) 2344 } 2345 2346 // Call invokes the (constant) contract method with params as input values and 2347 // sets the output to result. The result type might be a single field for simple 2348 // returns, a slice of interfaces for anonymous returns and a struct for named 2349 // returns. 2350 func (_ERC20Mintable *ERC20MintableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 2351 return _ERC20Mintable.Contract.contract.Call(opts, result, method, params...) 2352 } 2353 2354 // Transfer initiates a plain transaction to move funds to the contract, calling 2355 // its default method if one is available. 2356 func (_ERC20Mintable *ERC20MintableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 2357 return _ERC20Mintable.Contract.contract.Transfer(opts) 2358 } 2359 2360 // Transact invokes the (paid) contract method with params as input values. 2361 func (_ERC20Mintable *ERC20MintableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 2362 return _ERC20Mintable.Contract.contract.Transact(opts, method, params...) 2363 } 2364 2365 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 2366 // 2367 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 2368 func (_ERC20Mintable *ERC20MintableCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 2369 var ( 2370 ret0 = new(*big.Int) 2371 ) 2372 out := ret0 2373 err := _ERC20Mintable.contract.Call(opts, out, "allowance", owner, spender) 2374 return *ret0, err 2375 } 2376 2377 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 2378 // 2379 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 2380 func (_ERC20Mintable *ERC20MintableSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 2381 return _ERC20Mintable.Contract.Allowance(&_ERC20Mintable.CallOpts, owner, spender) 2382 } 2383 2384 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 2385 // 2386 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 2387 func (_ERC20Mintable *ERC20MintableCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 2388 return _ERC20Mintable.Contract.Allowance(&_ERC20Mintable.CallOpts, owner, spender) 2389 } 2390 2391 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 2392 // 2393 // Solidity: function balanceOf(address account) constant returns(uint256) 2394 func (_ERC20Mintable *ERC20MintableCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 2395 var ( 2396 ret0 = new(*big.Int) 2397 ) 2398 out := ret0 2399 err := _ERC20Mintable.contract.Call(opts, out, "balanceOf", account) 2400 return *ret0, err 2401 } 2402 2403 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 2404 // 2405 // Solidity: function balanceOf(address account) constant returns(uint256) 2406 func (_ERC20Mintable *ERC20MintableSession) BalanceOf(account common.Address) (*big.Int, error) { 2407 return _ERC20Mintable.Contract.BalanceOf(&_ERC20Mintable.CallOpts, account) 2408 } 2409 2410 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 2411 // 2412 // Solidity: function balanceOf(address account) constant returns(uint256) 2413 func (_ERC20Mintable *ERC20MintableCallerSession) BalanceOf(account common.Address) (*big.Int, error) { 2414 return _ERC20Mintable.Contract.BalanceOf(&_ERC20Mintable.CallOpts, account) 2415 } 2416 2417 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 2418 // 2419 // Solidity: function isMinter(address account) constant returns(bool) 2420 func (_ERC20Mintable *ERC20MintableCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) { 2421 var ( 2422 ret0 = new(bool) 2423 ) 2424 out := ret0 2425 err := _ERC20Mintable.contract.Call(opts, out, "isMinter", account) 2426 return *ret0, err 2427 } 2428 2429 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 2430 // 2431 // Solidity: function isMinter(address account) constant returns(bool) 2432 func (_ERC20Mintable *ERC20MintableSession) IsMinter(account common.Address) (bool, error) { 2433 return _ERC20Mintable.Contract.IsMinter(&_ERC20Mintable.CallOpts, account) 2434 } 2435 2436 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 2437 // 2438 // Solidity: function isMinter(address account) constant returns(bool) 2439 func (_ERC20Mintable *ERC20MintableCallerSession) IsMinter(account common.Address) (bool, error) { 2440 return _ERC20Mintable.Contract.IsMinter(&_ERC20Mintable.CallOpts, account) 2441 } 2442 2443 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 2444 // 2445 // Solidity: function totalSupply() constant returns(uint256) 2446 func (_ERC20Mintable *ERC20MintableCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 2447 var ( 2448 ret0 = new(*big.Int) 2449 ) 2450 out := ret0 2451 err := _ERC20Mintable.contract.Call(opts, out, "totalSupply") 2452 return *ret0, err 2453 } 2454 2455 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 2456 // 2457 // Solidity: function totalSupply() constant returns(uint256) 2458 func (_ERC20Mintable *ERC20MintableSession) TotalSupply() (*big.Int, error) { 2459 return _ERC20Mintable.Contract.TotalSupply(&_ERC20Mintable.CallOpts) 2460 } 2461 2462 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 2463 // 2464 // Solidity: function totalSupply() constant returns(uint256) 2465 func (_ERC20Mintable *ERC20MintableCallerSession) TotalSupply() (*big.Int, error) { 2466 return _ERC20Mintable.Contract.TotalSupply(&_ERC20Mintable.CallOpts) 2467 } 2468 2469 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 2470 // 2471 // Solidity: function addMinter(address account) returns() 2472 func (_ERC20Mintable *ERC20MintableTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) { 2473 return _ERC20Mintable.contract.Transact(opts, "addMinter", account) 2474 } 2475 2476 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 2477 // 2478 // Solidity: function addMinter(address account) returns() 2479 func (_ERC20Mintable *ERC20MintableSession) AddMinter(account common.Address) (*types.Transaction, error) { 2480 return _ERC20Mintable.Contract.AddMinter(&_ERC20Mintable.TransactOpts, account) 2481 } 2482 2483 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 2484 // 2485 // Solidity: function addMinter(address account) returns() 2486 func (_ERC20Mintable *ERC20MintableTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) { 2487 return _ERC20Mintable.Contract.AddMinter(&_ERC20Mintable.TransactOpts, account) 2488 } 2489 2490 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 2491 // 2492 // Solidity: function approve(address spender, uint256 amount) returns(bool) 2493 func (_ERC20Mintable *ERC20MintableTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 2494 return _ERC20Mintable.contract.Transact(opts, "approve", spender, amount) 2495 } 2496 2497 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 2498 // 2499 // Solidity: function approve(address spender, uint256 amount) returns(bool) 2500 func (_ERC20Mintable *ERC20MintableSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 2501 return _ERC20Mintable.Contract.Approve(&_ERC20Mintable.TransactOpts, spender, amount) 2502 } 2503 2504 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 2505 // 2506 // Solidity: function approve(address spender, uint256 amount) returns(bool) 2507 func (_ERC20Mintable *ERC20MintableTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 2508 return _ERC20Mintable.Contract.Approve(&_ERC20Mintable.TransactOpts, spender, amount) 2509 } 2510 2511 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 2512 // 2513 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 2514 func (_ERC20Mintable *ERC20MintableTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 2515 return _ERC20Mintable.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) 2516 } 2517 2518 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 2519 // 2520 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 2521 func (_ERC20Mintable *ERC20MintableSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 2522 return _ERC20Mintable.Contract.DecreaseAllowance(&_ERC20Mintable.TransactOpts, spender, subtractedValue) 2523 } 2524 2525 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 2526 // 2527 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 2528 func (_ERC20Mintable *ERC20MintableTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 2529 return _ERC20Mintable.Contract.DecreaseAllowance(&_ERC20Mintable.TransactOpts, spender, subtractedValue) 2530 } 2531 2532 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 2533 // 2534 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 2535 func (_ERC20Mintable *ERC20MintableTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 2536 return _ERC20Mintable.contract.Transact(opts, "increaseAllowance", spender, addedValue) 2537 } 2538 2539 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 2540 // 2541 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 2542 func (_ERC20Mintable *ERC20MintableSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 2543 return _ERC20Mintable.Contract.IncreaseAllowance(&_ERC20Mintable.TransactOpts, spender, addedValue) 2544 } 2545 2546 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 2547 // 2548 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 2549 func (_ERC20Mintable *ERC20MintableTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 2550 return _ERC20Mintable.Contract.IncreaseAllowance(&_ERC20Mintable.TransactOpts, spender, addedValue) 2551 } 2552 2553 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 2554 // 2555 // Solidity: function mint(address account, uint256 amount) returns(bool) 2556 func (_ERC20Mintable *ERC20MintableTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { 2557 return _ERC20Mintable.contract.Transact(opts, "mint", account, amount) 2558 } 2559 2560 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 2561 // 2562 // Solidity: function mint(address account, uint256 amount) returns(bool) 2563 func (_ERC20Mintable *ERC20MintableSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { 2564 return _ERC20Mintable.Contract.Mint(&_ERC20Mintable.TransactOpts, account, amount) 2565 } 2566 2567 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 2568 // 2569 // Solidity: function mint(address account, uint256 amount) returns(bool) 2570 func (_ERC20Mintable *ERC20MintableTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { 2571 return _ERC20Mintable.Contract.Mint(&_ERC20Mintable.TransactOpts, account, amount) 2572 } 2573 2574 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 2575 // 2576 // Solidity: function renounceMinter() returns() 2577 func (_ERC20Mintable *ERC20MintableTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) { 2578 return _ERC20Mintable.contract.Transact(opts, "renounceMinter") 2579 } 2580 2581 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 2582 // 2583 // Solidity: function renounceMinter() returns() 2584 func (_ERC20Mintable *ERC20MintableSession) RenounceMinter() (*types.Transaction, error) { 2585 return _ERC20Mintable.Contract.RenounceMinter(&_ERC20Mintable.TransactOpts) 2586 } 2587 2588 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 2589 // 2590 // Solidity: function renounceMinter() returns() 2591 func (_ERC20Mintable *ERC20MintableTransactorSession) RenounceMinter() (*types.Transaction, error) { 2592 return _ERC20Mintable.Contract.RenounceMinter(&_ERC20Mintable.TransactOpts) 2593 } 2594 2595 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 2596 // 2597 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 2598 func (_ERC20Mintable *ERC20MintableTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 2599 return _ERC20Mintable.contract.Transact(opts, "transfer", recipient, amount) 2600 } 2601 2602 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 2603 // 2604 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 2605 func (_ERC20Mintable *ERC20MintableSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 2606 return _ERC20Mintable.Contract.Transfer(&_ERC20Mintable.TransactOpts, recipient, amount) 2607 } 2608 2609 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 2610 // 2611 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 2612 func (_ERC20Mintable *ERC20MintableTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 2613 return _ERC20Mintable.Contract.Transfer(&_ERC20Mintable.TransactOpts, recipient, amount) 2614 } 2615 2616 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 2617 // 2618 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 2619 func (_ERC20Mintable *ERC20MintableTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 2620 return _ERC20Mintable.contract.Transact(opts, "transferFrom", sender, recipient, amount) 2621 } 2622 2623 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 2624 // 2625 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 2626 func (_ERC20Mintable *ERC20MintableSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 2627 return _ERC20Mintable.Contract.TransferFrom(&_ERC20Mintable.TransactOpts, sender, recipient, amount) 2628 } 2629 2630 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 2631 // 2632 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 2633 func (_ERC20Mintable *ERC20MintableTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 2634 return _ERC20Mintable.Contract.TransferFrom(&_ERC20Mintable.TransactOpts, sender, recipient, amount) 2635 } 2636 2637 // 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. 2638 type ERC20MintableApprovalIterator struct { 2639 Event *ERC20MintableApproval // Event containing the contract specifics and raw log 2640 2641 contract *bind.BoundContract // Generic contract to use for unpacking event data 2642 event string // Event name to use for unpacking event data 2643 2644 logs chan types.Log // Log channel receiving the found contract events 2645 sub ethereum.Subscription // Subscription for errors, completion and termination 2646 done bool // Whether the subscription completed delivering logs 2647 fail error // Occurred error to stop iteration 2648 } 2649 2650 // Next advances the iterator to the subsequent event, returning whether there 2651 // are any more events found. In case of a retrieval or parsing error, false is 2652 // returned and Error() can be queried for the exact failure. 2653 func (it *ERC20MintableApprovalIterator) Next() bool { 2654 // If the iterator failed, stop iterating 2655 if it.fail != nil { 2656 return false 2657 } 2658 // If the iterator completed, deliver directly whatever's available 2659 if it.done { 2660 select { 2661 case log := <-it.logs: 2662 it.Event = new(ERC20MintableApproval) 2663 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2664 it.fail = err 2665 return false 2666 } 2667 it.Event.Raw = log 2668 return true 2669 2670 default: 2671 return false 2672 } 2673 } 2674 // Iterator still in progress, wait for either a data or an error event 2675 select { 2676 case log := <-it.logs: 2677 it.Event = new(ERC20MintableApproval) 2678 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2679 it.fail = err 2680 return false 2681 } 2682 it.Event.Raw = log 2683 return true 2684 2685 case err := <-it.sub.Err(): 2686 it.done = true 2687 it.fail = err 2688 return it.Next() 2689 } 2690 } 2691 2692 // Error returns any retrieval or parsing error occurred during filtering. 2693 func (it *ERC20MintableApprovalIterator) Error() error { 2694 return it.fail 2695 } 2696 2697 // Close terminates the iteration process, releasing any pending underlying 2698 // resources. 2699 func (it *ERC20MintableApprovalIterator) Close() error { 2700 it.sub.Unsubscribe() 2701 return nil 2702 } 2703 2704 // ERC20MintableApproval represents a Approval event raised by the ERC20Mintable contract. 2705 type ERC20MintableApproval struct { 2706 Owner common.Address 2707 Spender common.Address 2708 Value *big.Int 2709 Raw types.Log // Blockchain specific contextual infos 2710 } 2711 2712 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 2713 // 2714 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 2715 func (_ERC20Mintable *ERC20MintableFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20MintableApprovalIterator, error) { 2716 2717 var ownerRule []interface{} 2718 for _, ownerItem := range owner { 2719 ownerRule = append(ownerRule, ownerItem) 2720 } 2721 var spenderRule []interface{} 2722 for _, spenderItem := range spender { 2723 spenderRule = append(spenderRule, spenderItem) 2724 } 2725 2726 logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 2727 if err != nil { 2728 return nil, err 2729 } 2730 return &ERC20MintableApprovalIterator{contract: _ERC20Mintable.contract, event: "Approval", logs: logs, sub: sub}, nil 2731 } 2732 2733 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 2734 // 2735 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 2736 func (_ERC20Mintable *ERC20MintableFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20MintableApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 2737 2738 var ownerRule []interface{} 2739 for _, ownerItem := range owner { 2740 ownerRule = append(ownerRule, ownerItem) 2741 } 2742 var spenderRule []interface{} 2743 for _, spenderItem := range spender { 2744 spenderRule = append(spenderRule, spenderItem) 2745 } 2746 2747 logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 2748 if err != nil { 2749 return nil, err 2750 } 2751 return event.NewSubscription(func(quit <-chan struct{}) error { 2752 defer sub.Unsubscribe() 2753 for { 2754 select { 2755 case log := <-logs: 2756 // New log arrived, parse the event and forward to the user 2757 event := new(ERC20MintableApproval) 2758 if err := _ERC20Mintable.contract.UnpackLog(event, "Approval", log); err != nil { 2759 return err 2760 } 2761 event.Raw = log 2762 2763 select { 2764 case sink <- event: 2765 case err := <-sub.Err(): 2766 return err 2767 case <-quit: 2768 return nil 2769 } 2770 case err := <-sub.Err(): 2771 return err 2772 case <-quit: 2773 return nil 2774 } 2775 } 2776 }), nil 2777 } 2778 2779 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 2780 // 2781 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 2782 func (_ERC20Mintable *ERC20MintableFilterer) ParseApproval(log types.Log) (*ERC20MintableApproval, error) { 2783 event := new(ERC20MintableApproval) 2784 if err := _ERC20Mintable.contract.UnpackLog(event, "Approval", log); err != nil { 2785 return nil, err 2786 } 2787 return event, nil 2788 } 2789 2790 // 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. 2791 type ERC20MintableMinterAddedIterator struct { 2792 Event *ERC20MintableMinterAdded // Event containing the contract specifics and raw log 2793 2794 contract *bind.BoundContract // Generic contract to use for unpacking event data 2795 event string // Event name to use for unpacking event data 2796 2797 logs chan types.Log // Log channel receiving the found contract events 2798 sub ethereum.Subscription // Subscription for errors, completion and termination 2799 done bool // Whether the subscription completed delivering logs 2800 fail error // Occurred error to stop iteration 2801 } 2802 2803 // Next advances the iterator to the subsequent event, returning whether there 2804 // are any more events found. In case of a retrieval or parsing error, false is 2805 // returned and Error() can be queried for the exact failure. 2806 func (it *ERC20MintableMinterAddedIterator) Next() bool { 2807 // If the iterator failed, stop iterating 2808 if it.fail != nil { 2809 return false 2810 } 2811 // If the iterator completed, deliver directly whatever's available 2812 if it.done { 2813 select { 2814 case log := <-it.logs: 2815 it.Event = new(ERC20MintableMinterAdded) 2816 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2817 it.fail = err 2818 return false 2819 } 2820 it.Event.Raw = log 2821 return true 2822 2823 default: 2824 return false 2825 } 2826 } 2827 // Iterator still in progress, wait for either a data or an error event 2828 select { 2829 case log := <-it.logs: 2830 it.Event = new(ERC20MintableMinterAdded) 2831 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2832 it.fail = err 2833 return false 2834 } 2835 it.Event.Raw = log 2836 return true 2837 2838 case err := <-it.sub.Err(): 2839 it.done = true 2840 it.fail = err 2841 return it.Next() 2842 } 2843 } 2844 2845 // Error returns any retrieval or parsing error occurred during filtering. 2846 func (it *ERC20MintableMinterAddedIterator) Error() error { 2847 return it.fail 2848 } 2849 2850 // Close terminates the iteration process, releasing any pending underlying 2851 // resources. 2852 func (it *ERC20MintableMinterAddedIterator) Close() error { 2853 it.sub.Unsubscribe() 2854 return nil 2855 } 2856 2857 // ERC20MintableMinterAdded represents a MinterAdded event raised by the ERC20Mintable contract. 2858 type ERC20MintableMinterAdded struct { 2859 Account common.Address 2860 Raw types.Log // Blockchain specific contextual infos 2861 } 2862 2863 // FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 2864 // 2865 // Solidity: event MinterAdded(address indexed account) 2866 func (_ERC20Mintable *ERC20MintableFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*ERC20MintableMinterAddedIterator, error) { 2867 2868 var accountRule []interface{} 2869 for _, accountItem := range account { 2870 accountRule = append(accountRule, accountItem) 2871 } 2872 2873 logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "MinterAdded", accountRule) 2874 if err != nil { 2875 return nil, err 2876 } 2877 return &ERC20MintableMinterAddedIterator{contract: _ERC20Mintable.contract, event: "MinterAdded", logs: logs, sub: sub}, nil 2878 } 2879 2880 // WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 2881 // 2882 // Solidity: event MinterAdded(address indexed account) 2883 func (_ERC20Mintable *ERC20MintableFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *ERC20MintableMinterAdded, account []common.Address) (event.Subscription, error) { 2884 2885 var accountRule []interface{} 2886 for _, accountItem := range account { 2887 accountRule = append(accountRule, accountItem) 2888 } 2889 2890 logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "MinterAdded", accountRule) 2891 if err != nil { 2892 return nil, err 2893 } 2894 return event.NewSubscription(func(quit <-chan struct{}) error { 2895 defer sub.Unsubscribe() 2896 for { 2897 select { 2898 case log := <-logs: 2899 // New log arrived, parse the event and forward to the user 2900 event := new(ERC20MintableMinterAdded) 2901 if err := _ERC20Mintable.contract.UnpackLog(event, "MinterAdded", log); err != nil { 2902 return err 2903 } 2904 event.Raw = log 2905 2906 select { 2907 case sink <- event: 2908 case err := <-sub.Err(): 2909 return err 2910 case <-quit: 2911 return nil 2912 } 2913 case err := <-sub.Err(): 2914 return err 2915 case <-quit: 2916 return nil 2917 } 2918 } 2919 }), nil 2920 } 2921 2922 // ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 2923 // 2924 // Solidity: event MinterAdded(address indexed account) 2925 func (_ERC20Mintable *ERC20MintableFilterer) ParseMinterAdded(log types.Log) (*ERC20MintableMinterAdded, error) { 2926 event := new(ERC20MintableMinterAdded) 2927 if err := _ERC20Mintable.contract.UnpackLog(event, "MinterAdded", log); err != nil { 2928 return nil, err 2929 } 2930 return event, nil 2931 } 2932 2933 // 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. 2934 type ERC20MintableMinterRemovedIterator struct { 2935 Event *ERC20MintableMinterRemoved // Event containing the contract specifics and raw log 2936 2937 contract *bind.BoundContract // Generic contract to use for unpacking event data 2938 event string // Event name to use for unpacking event data 2939 2940 logs chan types.Log // Log channel receiving the found contract events 2941 sub ethereum.Subscription // Subscription for errors, completion and termination 2942 done bool // Whether the subscription completed delivering logs 2943 fail error // Occurred error to stop iteration 2944 } 2945 2946 // Next advances the iterator to the subsequent event, returning whether there 2947 // are any more events found. In case of a retrieval or parsing error, false is 2948 // returned and Error() can be queried for the exact failure. 2949 func (it *ERC20MintableMinterRemovedIterator) Next() bool { 2950 // If the iterator failed, stop iterating 2951 if it.fail != nil { 2952 return false 2953 } 2954 // If the iterator completed, deliver directly whatever's available 2955 if it.done { 2956 select { 2957 case log := <-it.logs: 2958 it.Event = new(ERC20MintableMinterRemoved) 2959 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2960 it.fail = err 2961 return false 2962 } 2963 it.Event.Raw = log 2964 return true 2965 2966 default: 2967 return false 2968 } 2969 } 2970 // Iterator still in progress, wait for either a data or an error event 2971 select { 2972 case log := <-it.logs: 2973 it.Event = new(ERC20MintableMinterRemoved) 2974 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 2975 it.fail = err 2976 return false 2977 } 2978 it.Event.Raw = log 2979 return true 2980 2981 case err := <-it.sub.Err(): 2982 it.done = true 2983 it.fail = err 2984 return it.Next() 2985 } 2986 } 2987 2988 // Error returns any retrieval or parsing error occurred during filtering. 2989 func (it *ERC20MintableMinterRemovedIterator) Error() error { 2990 return it.fail 2991 } 2992 2993 // Close terminates the iteration process, releasing any pending underlying 2994 // resources. 2995 func (it *ERC20MintableMinterRemovedIterator) Close() error { 2996 it.sub.Unsubscribe() 2997 return nil 2998 } 2999 3000 // ERC20MintableMinterRemoved represents a MinterRemoved event raised by the ERC20Mintable contract. 3001 type ERC20MintableMinterRemoved struct { 3002 Account common.Address 3003 Raw types.Log // Blockchain specific contextual infos 3004 } 3005 3006 // FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 3007 // 3008 // Solidity: event MinterRemoved(address indexed account) 3009 func (_ERC20Mintable *ERC20MintableFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*ERC20MintableMinterRemovedIterator, error) { 3010 3011 var accountRule []interface{} 3012 for _, accountItem := range account { 3013 accountRule = append(accountRule, accountItem) 3014 } 3015 3016 logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "MinterRemoved", accountRule) 3017 if err != nil { 3018 return nil, err 3019 } 3020 return &ERC20MintableMinterRemovedIterator{contract: _ERC20Mintable.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil 3021 } 3022 3023 // WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 3024 // 3025 // Solidity: event MinterRemoved(address indexed account) 3026 func (_ERC20Mintable *ERC20MintableFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *ERC20MintableMinterRemoved, account []common.Address) (event.Subscription, error) { 3027 3028 var accountRule []interface{} 3029 for _, accountItem := range account { 3030 accountRule = append(accountRule, accountItem) 3031 } 3032 3033 logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "MinterRemoved", accountRule) 3034 if err != nil { 3035 return nil, err 3036 } 3037 return event.NewSubscription(func(quit <-chan struct{}) error { 3038 defer sub.Unsubscribe() 3039 for { 3040 select { 3041 case log := <-logs: 3042 // New log arrived, parse the event and forward to the user 3043 event := new(ERC20MintableMinterRemoved) 3044 if err := _ERC20Mintable.contract.UnpackLog(event, "MinterRemoved", log); err != nil { 3045 return err 3046 } 3047 event.Raw = log 3048 3049 select { 3050 case sink <- event: 3051 case err := <-sub.Err(): 3052 return err 3053 case <-quit: 3054 return nil 3055 } 3056 case err := <-sub.Err(): 3057 return err 3058 case <-quit: 3059 return nil 3060 } 3061 } 3062 }), nil 3063 } 3064 3065 // ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 3066 // 3067 // Solidity: event MinterRemoved(address indexed account) 3068 func (_ERC20Mintable *ERC20MintableFilterer) ParseMinterRemoved(log types.Log) (*ERC20MintableMinterRemoved, error) { 3069 event := new(ERC20MintableMinterRemoved) 3070 if err := _ERC20Mintable.contract.UnpackLog(event, "MinterRemoved", log); err != nil { 3071 return nil, err 3072 } 3073 return event, nil 3074 } 3075 3076 // 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. 3077 type ERC20MintableTransferIterator struct { 3078 Event *ERC20MintableTransfer // Event containing the contract specifics and raw log 3079 3080 contract *bind.BoundContract // Generic contract to use for unpacking event data 3081 event string // Event name to use for unpacking event data 3082 3083 logs chan types.Log // Log channel receiving the found contract events 3084 sub ethereum.Subscription // Subscription for errors, completion and termination 3085 done bool // Whether the subscription completed delivering logs 3086 fail error // Occurred error to stop iteration 3087 } 3088 3089 // Next advances the iterator to the subsequent event, returning whether there 3090 // are any more events found. In case of a retrieval or parsing error, false is 3091 // returned and Error() can be queried for the exact failure. 3092 func (it *ERC20MintableTransferIterator) Next() bool { 3093 // If the iterator failed, stop iterating 3094 if it.fail != nil { 3095 return false 3096 } 3097 // If the iterator completed, deliver directly whatever's available 3098 if it.done { 3099 select { 3100 case log := <-it.logs: 3101 it.Event = new(ERC20MintableTransfer) 3102 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3103 it.fail = err 3104 return false 3105 } 3106 it.Event.Raw = log 3107 return true 3108 3109 default: 3110 return false 3111 } 3112 } 3113 // Iterator still in progress, wait for either a data or an error event 3114 select { 3115 case log := <-it.logs: 3116 it.Event = new(ERC20MintableTransfer) 3117 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3118 it.fail = err 3119 return false 3120 } 3121 it.Event.Raw = log 3122 return true 3123 3124 case err := <-it.sub.Err(): 3125 it.done = true 3126 it.fail = err 3127 return it.Next() 3128 } 3129 } 3130 3131 // Error returns any retrieval or parsing error occurred during filtering. 3132 func (it *ERC20MintableTransferIterator) Error() error { 3133 return it.fail 3134 } 3135 3136 // Close terminates the iteration process, releasing any pending underlying 3137 // resources. 3138 func (it *ERC20MintableTransferIterator) Close() error { 3139 it.sub.Unsubscribe() 3140 return nil 3141 } 3142 3143 // ERC20MintableTransfer represents a Transfer event raised by the ERC20Mintable contract. 3144 type ERC20MintableTransfer struct { 3145 From common.Address 3146 To common.Address 3147 Value *big.Int 3148 Raw types.Log // Blockchain specific contextual infos 3149 } 3150 3151 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 3152 // 3153 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 3154 func (_ERC20Mintable *ERC20MintableFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20MintableTransferIterator, error) { 3155 3156 var fromRule []interface{} 3157 for _, fromItem := range from { 3158 fromRule = append(fromRule, fromItem) 3159 } 3160 var toRule []interface{} 3161 for _, toItem := range to { 3162 toRule = append(toRule, toItem) 3163 } 3164 3165 logs, sub, err := _ERC20Mintable.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 3166 if err != nil { 3167 return nil, err 3168 } 3169 return &ERC20MintableTransferIterator{contract: _ERC20Mintable.contract, event: "Transfer", logs: logs, sub: sub}, nil 3170 } 3171 3172 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 3173 // 3174 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 3175 func (_ERC20Mintable *ERC20MintableFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20MintableTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 3176 3177 var fromRule []interface{} 3178 for _, fromItem := range from { 3179 fromRule = append(fromRule, fromItem) 3180 } 3181 var toRule []interface{} 3182 for _, toItem := range to { 3183 toRule = append(toRule, toItem) 3184 } 3185 3186 logs, sub, err := _ERC20Mintable.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 3187 if err != nil { 3188 return nil, err 3189 } 3190 return event.NewSubscription(func(quit <-chan struct{}) error { 3191 defer sub.Unsubscribe() 3192 for { 3193 select { 3194 case log := <-logs: 3195 // New log arrived, parse the event and forward to the user 3196 event := new(ERC20MintableTransfer) 3197 if err := _ERC20Mintable.contract.UnpackLog(event, "Transfer", log); err != nil { 3198 return err 3199 } 3200 event.Raw = log 3201 3202 select { 3203 case sink <- event: 3204 case err := <-sub.Err(): 3205 return err 3206 case <-quit: 3207 return nil 3208 } 3209 case err := <-sub.Err(): 3210 return err 3211 case <-quit: 3212 return nil 3213 } 3214 } 3215 }), nil 3216 } 3217 3218 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 3219 // 3220 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 3221 func (_ERC20Mintable *ERC20MintableFilterer) ParseTransfer(log types.Log) (*ERC20MintableTransfer, error) { 3222 event := new(ERC20MintableTransfer) 3223 if err := _ERC20Mintable.contract.UnpackLog(event, "Transfer", log); err != nil { 3224 return nil, err 3225 } 3226 return event, nil 3227 } 3228 3229 // ERC20OnApproveABI is the input ABI used to generate the binding from. 3230 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\"}]" 3231 3232 // ERC20OnApproveFuncSigs maps the 4-byte function signature to its string representation. 3233 var ERC20OnApproveFuncSigs = map[string]string{ 3234 "6cd28f9a": "INTERFACE_ID_ON_APPROVE()", 3235 "dd62ed3e": "allowance(address,address)", 3236 "095ea7b3": "approve(address,uint256)", 3237 "cae9ca51": "approveAndCall(address,uint256,bytes)", 3238 "70a08231": "balanceOf(address)", 3239 "a457c2d7": "decreaseAllowance(address,uint256)", 3240 "39509351": "increaseAllowance(address,uint256)", 3241 "18160ddd": "totalSupply()", 3242 "a9059cbb": "transfer(address,uint256)", 3243 "23b872dd": "transferFrom(address,address,uint256)", 3244 } 3245 3246 // ERC20OnApproveBin is the compiled bytecode used for deploying new contracts. 3247 var ERC20OnApproveBin = "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" 3248 3249 // DeployERC20OnApprove deploys a new Ethereum contract, binding an instance of ERC20OnApprove to it. 3250 func DeployERC20OnApprove(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *ERC20OnApprove, error) { 3251 parsed, err := abi.JSON(strings.NewReader(ERC20OnApproveABI)) 3252 if err != nil { 3253 return common.Address{}, nil, nil, err 3254 } 3255 3256 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(ERC20OnApproveBin), backend) 3257 if err != nil { 3258 return common.Address{}, nil, nil, err 3259 } 3260 return address, tx, &ERC20OnApprove{ERC20OnApproveCaller: ERC20OnApproveCaller{contract: contract}, ERC20OnApproveTransactor: ERC20OnApproveTransactor{contract: contract}, ERC20OnApproveFilterer: ERC20OnApproveFilterer{contract: contract}}, nil 3261 } 3262 3263 // ERC20OnApprove is an auto generated Go binding around an Ethereum contract. 3264 type ERC20OnApprove struct { 3265 ERC20OnApproveCaller // Read-only binding to the contract 3266 ERC20OnApproveTransactor // Write-only binding to the contract 3267 ERC20OnApproveFilterer // Log filterer for contract events 3268 } 3269 3270 // ERC20OnApproveCaller is an auto generated read-only Go binding around an Ethereum contract. 3271 type ERC20OnApproveCaller struct { 3272 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3273 } 3274 3275 // ERC20OnApproveTransactor is an auto generated write-only Go binding around an Ethereum contract. 3276 type ERC20OnApproveTransactor struct { 3277 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3278 } 3279 3280 // ERC20OnApproveFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 3281 type ERC20OnApproveFilterer struct { 3282 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3283 } 3284 3285 // ERC20OnApproveSession is an auto generated Go binding around an Ethereum contract, 3286 // with pre-set call and transact options. 3287 type ERC20OnApproveSession struct { 3288 Contract *ERC20OnApprove // Generic contract binding to set the session for 3289 CallOpts bind.CallOpts // Call options to use throughout this session 3290 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 3291 } 3292 3293 // ERC20OnApproveCallerSession is an auto generated read-only Go binding around an Ethereum contract, 3294 // with pre-set call options. 3295 type ERC20OnApproveCallerSession struct { 3296 Contract *ERC20OnApproveCaller // Generic contract caller binding to set the session for 3297 CallOpts bind.CallOpts // Call options to use throughout this session 3298 } 3299 3300 // ERC20OnApproveTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 3301 // with pre-set transact options. 3302 type ERC20OnApproveTransactorSession struct { 3303 Contract *ERC20OnApproveTransactor // Generic contract transactor binding to set the session for 3304 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 3305 } 3306 3307 // ERC20OnApproveRaw is an auto generated low-level Go binding around an Ethereum contract. 3308 type ERC20OnApproveRaw struct { 3309 Contract *ERC20OnApprove // Generic contract binding to access the raw methods on 3310 } 3311 3312 // ERC20OnApproveCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 3313 type ERC20OnApproveCallerRaw struct { 3314 Contract *ERC20OnApproveCaller // Generic read-only contract binding to access the raw methods on 3315 } 3316 3317 // ERC20OnApproveTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 3318 type ERC20OnApproveTransactorRaw struct { 3319 Contract *ERC20OnApproveTransactor // Generic write-only contract binding to access the raw methods on 3320 } 3321 3322 // NewERC20OnApprove creates a new instance of ERC20OnApprove, bound to a specific deployed contract. 3323 func NewERC20OnApprove(address common.Address, backend bind.ContractBackend) (*ERC20OnApprove, error) { 3324 contract, err := bindERC20OnApprove(address, backend, backend, backend) 3325 if err != nil { 3326 return nil, err 3327 } 3328 return &ERC20OnApprove{ERC20OnApproveCaller: ERC20OnApproveCaller{contract: contract}, ERC20OnApproveTransactor: ERC20OnApproveTransactor{contract: contract}, ERC20OnApproveFilterer: ERC20OnApproveFilterer{contract: contract}}, nil 3329 } 3330 3331 // NewERC20OnApproveCaller creates a new read-only instance of ERC20OnApprove, bound to a specific deployed contract. 3332 func NewERC20OnApproveCaller(address common.Address, caller bind.ContractCaller) (*ERC20OnApproveCaller, error) { 3333 contract, err := bindERC20OnApprove(address, caller, nil, nil) 3334 if err != nil { 3335 return nil, err 3336 } 3337 return &ERC20OnApproveCaller{contract: contract}, nil 3338 } 3339 3340 // NewERC20OnApproveTransactor creates a new write-only instance of ERC20OnApprove, bound to a specific deployed contract. 3341 func NewERC20OnApproveTransactor(address common.Address, transactor bind.ContractTransactor) (*ERC20OnApproveTransactor, error) { 3342 contract, err := bindERC20OnApprove(address, nil, transactor, nil) 3343 if err != nil { 3344 return nil, err 3345 } 3346 return &ERC20OnApproveTransactor{contract: contract}, nil 3347 } 3348 3349 // NewERC20OnApproveFilterer creates a new log filterer instance of ERC20OnApprove, bound to a specific deployed contract. 3350 func NewERC20OnApproveFilterer(address common.Address, filterer bind.ContractFilterer) (*ERC20OnApproveFilterer, error) { 3351 contract, err := bindERC20OnApprove(address, nil, nil, filterer) 3352 if err != nil { 3353 return nil, err 3354 } 3355 return &ERC20OnApproveFilterer{contract: contract}, nil 3356 } 3357 3358 // bindERC20OnApprove binds a generic wrapper to an already deployed contract. 3359 func bindERC20OnApprove(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 3360 parsed, err := abi.JSON(strings.NewReader(ERC20OnApproveABI)) 3361 if err != nil { 3362 return nil, err 3363 } 3364 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 3365 } 3366 3367 // Call invokes the (constant) contract method with params as input values and 3368 // sets the output to result. The result type might be a single field for simple 3369 // returns, a slice of interfaces for anonymous returns and a struct for named 3370 // returns. 3371 func (_ERC20OnApprove *ERC20OnApproveRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 3372 return _ERC20OnApprove.Contract.ERC20OnApproveCaller.contract.Call(opts, result, method, params...) 3373 } 3374 3375 // Transfer initiates a plain transaction to move funds to the contract, calling 3376 // its default method if one is available. 3377 func (_ERC20OnApprove *ERC20OnApproveRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 3378 return _ERC20OnApprove.Contract.ERC20OnApproveTransactor.contract.Transfer(opts) 3379 } 3380 3381 // Transact invokes the (paid) contract method with params as input values. 3382 func (_ERC20OnApprove *ERC20OnApproveRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 3383 return _ERC20OnApprove.Contract.ERC20OnApproveTransactor.contract.Transact(opts, method, params...) 3384 } 3385 3386 // Call invokes the (constant) contract method with params as input values and 3387 // sets the output to result. The result type might be a single field for simple 3388 // returns, a slice of interfaces for anonymous returns and a struct for named 3389 // returns. 3390 func (_ERC20OnApprove *ERC20OnApproveCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 3391 return _ERC20OnApprove.Contract.contract.Call(opts, result, method, params...) 3392 } 3393 3394 // Transfer initiates a plain transaction to move funds to the contract, calling 3395 // its default method if one is available. 3396 func (_ERC20OnApprove *ERC20OnApproveTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 3397 return _ERC20OnApprove.Contract.contract.Transfer(opts) 3398 } 3399 3400 // Transact invokes the (paid) contract method with params as input values. 3401 func (_ERC20OnApprove *ERC20OnApproveTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 3402 return _ERC20OnApprove.Contract.contract.Transact(opts, method, params...) 3403 } 3404 3405 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 3406 // 3407 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 3408 func (_ERC20OnApprove *ERC20OnApproveCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) { 3409 var ( 3410 ret0 = new([4]byte) 3411 ) 3412 out := ret0 3413 err := _ERC20OnApprove.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE") 3414 return *ret0, err 3415 } 3416 3417 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 3418 // 3419 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 3420 func (_ERC20OnApprove *ERC20OnApproveSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 3421 return _ERC20OnApprove.Contract.INTERFACEIDONAPPROVE(&_ERC20OnApprove.CallOpts) 3422 } 3423 3424 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 3425 // 3426 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 3427 func (_ERC20OnApprove *ERC20OnApproveCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 3428 return _ERC20OnApprove.Contract.INTERFACEIDONAPPROVE(&_ERC20OnApprove.CallOpts) 3429 } 3430 3431 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 3432 // 3433 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 3434 func (_ERC20OnApprove *ERC20OnApproveCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 3435 var ( 3436 ret0 = new(*big.Int) 3437 ) 3438 out := ret0 3439 err := _ERC20OnApprove.contract.Call(opts, out, "allowance", owner, spender) 3440 return *ret0, err 3441 } 3442 3443 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 3444 // 3445 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 3446 func (_ERC20OnApprove *ERC20OnApproveSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 3447 return _ERC20OnApprove.Contract.Allowance(&_ERC20OnApprove.CallOpts, owner, spender) 3448 } 3449 3450 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 3451 // 3452 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 3453 func (_ERC20OnApprove *ERC20OnApproveCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 3454 return _ERC20OnApprove.Contract.Allowance(&_ERC20OnApprove.CallOpts, owner, spender) 3455 } 3456 3457 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 3458 // 3459 // Solidity: function balanceOf(address account) constant returns(uint256) 3460 func (_ERC20OnApprove *ERC20OnApproveCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 3461 var ( 3462 ret0 = new(*big.Int) 3463 ) 3464 out := ret0 3465 err := _ERC20OnApprove.contract.Call(opts, out, "balanceOf", account) 3466 return *ret0, err 3467 } 3468 3469 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 3470 // 3471 // Solidity: function balanceOf(address account) constant returns(uint256) 3472 func (_ERC20OnApprove *ERC20OnApproveSession) BalanceOf(account common.Address) (*big.Int, error) { 3473 return _ERC20OnApprove.Contract.BalanceOf(&_ERC20OnApprove.CallOpts, account) 3474 } 3475 3476 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 3477 // 3478 // Solidity: function balanceOf(address account) constant returns(uint256) 3479 func (_ERC20OnApprove *ERC20OnApproveCallerSession) BalanceOf(account common.Address) (*big.Int, error) { 3480 return _ERC20OnApprove.Contract.BalanceOf(&_ERC20OnApprove.CallOpts, account) 3481 } 3482 3483 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 3484 // 3485 // Solidity: function totalSupply() constant returns(uint256) 3486 func (_ERC20OnApprove *ERC20OnApproveCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 3487 var ( 3488 ret0 = new(*big.Int) 3489 ) 3490 out := ret0 3491 err := _ERC20OnApprove.contract.Call(opts, out, "totalSupply") 3492 return *ret0, err 3493 } 3494 3495 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 3496 // 3497 // Solidity: function totalSupply() constant returns(uint256) 3498 func (_ERC20OnApprove *ERC20OnApproveSession) TotalSupply() (*big.Int, error) { 3499 return _ERC20OnApprove.Contract.TotalSupply(&_ERC20OnApprove.CallOpts) 3500 } 3501 3502 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 3503 // 3504 // Solidity: function totalSupply() constant returns(uint256) 3505 func (_ERC20OnApprove *ERC20OnApproveCallerSession) TotalSupply() (*big.Int, error) { 3506 return _ERC20OnApprove.Contract.TotalSupply(&_ERC20OnApprove.CallOpts) 3507 } 3508 3509 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 3510 // 3511 // Solidity: function approve(address spender, uint256 amount) returns(bool) 3512 func (_ERC20OnApprove *ERC20OnApproveTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 3513 return _ERC20OnApprove.contract.Transact(opts, "approve", spender, amount) 3514 } 3515 3516 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 3517 // 3518 // Solidity: function approve(address spender, uint256 amount) returns(bool) 3519 func (_ERC20OnApprove *ERC20OnApproveSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 3520 return _ERC20OnApprove.Contract.Approve(&_ERC20OnApprove.TransactOpts, spender, amount) 3521 } 3522 3523 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 3524 // 3525 // Solidity: function approve(address spender, uint256 amount) returns(bool) 3526 func (_ERC20OnApprove *ERC20OnApproveTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 3527 return _ERC20OnApprove.Contract.Approve(&_ERC20OnApprove.TransactOpts, spender, amount) 3528 } 3529 3530 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 3531 // 3532 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 3533 func (_ERC20OnApprove *ERC20OnApproveTransactor) ApproveAndCall(opts *bind.TransactOpts, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 3534 return _ERC20OnApprove.contract.Transact(opts, "approveAndCall", spender, amount, data) 3535 } 3536 3537 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 3538 // 3539 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 3540 func (_ERC20OnApprove *ERC20OnApproveSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 3541 return _ERC20OnApprove.Contract.ApproveAndCall(&_ERC20OnApprove.TransactOpts, spender, amount, data) 3542 } 3543 3544 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 3545 // 3546 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 3547 func (_ERC20OnApprove *ERC20OnApproveTransactorSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 3548 return _ERC20OnApprove.Contract.ApproveAndCall(&_ERC20OnApprove.TransactOpts, spender, amount, data) 3549 } 3550 3551 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 3552 // 3553 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 3554 func (_ERC20OnApprove *ERC20OnApproveTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 3555 return _ERC20OnApprove.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) 3556 } 3557 3558 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 3559 // 3560 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 3561 func (_ERC20OnApprove *ERC20OnApproveSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 3562 return _ERC20OnApprove.Contract.DecreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, subtractedValue) 3563 } 3564 3565 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 3566 // 3567 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 3568 func (_ERC20OnApprove *ERC20OnApproveTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 3569 return _ERC20OnApprove.Contract.DecreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, subtractedValue) 3570 } 3571 3572 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 3573 // 3574 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 3575 func (_ERC20OnApprove *ERC20OnApproveTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 3576 return _ERC20OnApprove.contract.Transact(opts, "increaseAllowance", spender, addedValue) 3577 } 3578 3579 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 3580 // 3581 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 3582 func (_ERC20OnApprove *ERC20OnApproveSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 3583 return _ERC20OnApprove.Contract.IncreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, addedValue) 3584 } 3585 3586 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 3587 // 3588 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 3589 func (_ERC20OnApprove *ERC20OnApproveTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 3590 return _ERC20OnApprove.Contract.IncreaseAllowance(&_ERC20OnApprove.TransactOpts, spender, addedValue) 3591 } 3592 3593 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 3594 // 3595 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 3596 func (_ERC20OnApprove *ERC20OnApproveTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 3597 return _ERC20OnApprove.contract.Transact(opts, "transfer", recipient, amount) 3598 } 3599 3600 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 3601 // 3602 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 3603 func (_ERC20OnApprove *ERC20OnApproveSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 3604 return _ERC20OnApprove.Contract.Transfer(&_ERC20OnApprove.TransactOpts, recipient, amount) 3605 } 3606 3607 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 3608 // 3609 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 3610 func (_ERC20OnApprove *ERC20OnApproveTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 3611 return _ERC20OnApprove.Contract.Transfer(&_ERC20OnApprove.TransactOpts, recipient, amount) 3612 } 3613 3614 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 3615 // 3616 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 3617 func (_ERC20OnApprove *ERC20OnApproveTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 3618 return _ERC20OnApprove.contract.Transact(opts, "transferFrom", sender, recipient, amount) 3619 } 3620 3621 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 3622 // 3623 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 3624 func (_ERC20OnApprove *ERC20OnApproveSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 3625 return _ERC20OnApprove.Contract.TransferFrom(&_ERC20OnApprove.TransactOpts, sender, recipient, amount) 3626 } 3627 3628 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 3629 // 3630 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 3631 func (_ERC20OnApprove *ERC20OnApproveTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 3632 return _ERC20OnApprove.Contract.TransferFrom(&_ERC20OnApprove.TransactOpts, sender, recipient, amount) 3633 } 3634 3635 // 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. 3636 type ERC20OnApproveApprovalIterator struct { 3637 Event *ERC20OnApproveApproval // Event containing the contract specifics and raw log 3638 3639 contract *bind.BoundContract // Generic contract to use for unpacking event data 3640 event string // Event name to use for unpacking event data 3641 3642 logs chan types.Log // Log channel receiving the found contract events 3643 sub ethereum.Subscription // Subscription for errors, completion and termination 3644 done bool // Whether the subscription completed delivering logs 3645 fail error // Occurred error to stop iteration 3646 } 3647 3648 // Next advances the iterator to the subsequent event, returning whether there 3649 // are any more events found. In case of a retrieval or parsing error, false is 3650 // returned and Error() can be queried for the exact failure. 3651 func (it *ERC20OnApproveApprovalIterator) Next() bool { 3652 // If the iterator failed, stop iterating 3653 if it.fail != nil { 3654 return false 3655 } 3656 // If the iterator completed, deliver directly whatever's available 3657 if it.done { 3658 select { 3659 case log := <-it.logs: 3660 it.Event = new(ERC20OnApproveApproval) 3661 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3662 it.fail = err 3663 return false 3664 } 3665 it.Event.Raw = log 3666 return true 3667 3668 default: 3669 return false 3670 } 3671 } 3672 // Iterator still in progress, wait for either a data or an error event 3673 select { 3674 case log := <-it.logs: 3675 it.Event = new(ERC20OnApproveApproval) 3676 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3677 it.fail = err 3678 return false 3679 } 3680 it.Event.Raw = log 3681 return true 3682 3683 case err := <-it.sub.Err(): 3684 it.done = true 3685 it.fail = err 3686 return it.Next() 3687 } 3688 } 3689 3690 // Error returns any retrieval or parsing error occurred during filtering. 3691 func (it *ERC20OnApproveApprovalIterator) Error() error { 3692 return it.fail 3693 } 3694 3695 // Close terminates the iteration process, releasing any pending underlying 3696 // resources. 3697 func (it *ERC20OnApproveApprovalIterator) Close() error { 3698 it.sub.Unsubscribe() 3699 return nil 3700 } 3701 3702 // ERC20OnApproveApproval represents a Approval event raised by the ERC20OnApprove contract. 3703 type ERC20OnApproveApproval struct { 3704 Owner common.Address 3705 Spender common.Address 3706 Value *big.Int 3707 Raw types.Log // Blockchain specific contextual infos 3708 } 3709 3710 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 3711 // 3712 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 3713 func (_ERC20OnApprove *ERC20OnApproveFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*ERC20OnApproveApprovalIterator, error) { 3714 3715 var ownerRule []interface{} 3716 for _, ownerItem := range owner { 3717 ownerRule = append(ownerRule, ownerItem) 3718 } 3719 var spenderRule []interface{} 3720 for _, spenderItem := range spender { 3721 spenderRule = append(spenderRule, spenderItem) 3722 } 3723 3724 logs, sub, err := _ERC20OnApprove.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 3725 if err != nil { 3726 return nil, err 3727 } 3728 return &ERC20OnApproveApprovalIterator{contract: _ERC20OnApprove.contract, event: "Approval", logs: logs, sub: sub}, nil 3729 } 3730 3731 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 3732 // 3733 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 3734 func (_ERC20OnApprove *ERC20OnApproveFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *ERC20OnApproveApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 3735 3736 var ownerRule []interface{} 3737 for _, ownerItem := range owner { 3738 ownerRule = append(ownerRule, ownerItem) 3739 } 3740 var spenderRule []interface{} 3741 for _, spenderItem := range spender { 3742 spenderRule = append(spenderRule, spenderItem) 3743 } 3744 3745 logs, sub, err := _ERC20OnApprove.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 3746 if err != nil { 3747 return nil, err 3748 } 3749 return event.NewSubscription(func(quit <-chan struct{}) error { 3750 defer sub.Unsubscribe() 3751 for { 3752 select { 3753 case log := <-logs: 3754 // New log arrived, parse the event and forward to the user 3755 event := new(ERC20OnApproveApproval) 3756 if err := _ERC20OnApprove.contract.UnpackLog(event, "Approval", log); err != nil { 3757 return err 3758 } 3759 event.Raw = log 3760 3761 select { 3762 case sink <- event: 3763 case err := <-sub.Err(): 3764 return err 3765 case <-quit: 3766 return nil 3767 } 3768 case err := <-sub.Err(): 3769 return err 3770 case <-quit: 3771 return nil 3772 } 3773 } 3774 }), nil 3775 } 3776 3777 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 3778 // 3779 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 3780 func (_ERC20OnApprove *ERC20OnApproveFilterer) ParseApproval(log types.Log) (*ERC20OnApproveApproval, error) { 3781 event := new(ERC20OnApproveApproval) 3782 if err := _ERC20OnApprove.contract.UnpackLog(event, "Approval", log); err != nil { 3783 return nil, err 3784 } 3785 return event, nil 3786 } 3787 3788 // 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. 3789 type ERC20OnApproveTransferIterator struct { 3790 Event *ERC20OnApproveTransfer // Event containing the contract specifics and raw log 3791 3792 contract *bind.BoundContract // Generic contract to use for unpacking event data 3793 event string // Event name to use for unpacking event data 3794 3795 logs chan types.Log // Log channel receiving the found contract events 3796 sub ethereum.Subscription // Subscription for errors, completion and termination 3797 done bool // Whether the subscription completed delivering logs 3798 fail error // Occurred error to stop iteration 3799 } 3800 3801 // Next advances the iterator to the subsequent event, returning whether there 3802 // are any more events found. In case of a retrieval or parsing error, false is 3803 // returned and Error() can be queried for the exact failure. 3804 func (it *ERC20OnApproveTransferIterator) Next() bool { 3805 // If the iterator failed, stop iterating 3806 if it.fail != nil { 3807 return false 3808 } 3809 // If the iterator completed, deliver directly whatever's available 3810 if it.done { 3811 select { 3812 case log := <-it.logs: 3813 it.Event = new(ERC20OnApproveTransfer) 3814 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3815 it.fail = err 3816 return false 3817 } 3818 it.Event.Raw = log 3819 return true 3820 3821 default: 3822 return false 3823 } 3824 } 3825 // Iterator still in progress, wait for either a data or an error event 3826 select { 3827 case log := <-it.logs: 3828 it.Event = new(ERC20OnApproveTransfer) 3829 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 3830 it.fail = err 3831 return false 3832 } 3833 it.Event.Raw = log 3834 return true 3835 3836 case err := <-it.sub.Err(): 3837 it.done = true 3838 it.fail = err 3839 return it.Next() 3840 } 3841 } 3842 3843 // Error returns any retrieval or parsing error occurred during filtering. 3844 func (it *ERC20OnApproveTransferIterator) Error() error { 3845 return it.fail 3846 } 3847 3848 // Close terminates the iteration process, releasing any pending underlying 3849 // resources. 3850 func (it *ERC20OnApproveTransferIterator) Close() error { 3851 it.sub.Unsubscribe() 3852 return nil 3853 } 3854 3855 // ERC20OnApproveTransfer represents a Transfer event raised by the ERC20OnApprove contract. 3856 type ERC20OnApproveTransfer struct { 3857 From common.Address 3858 To common.Address 3859 Value *big.Int 3860 Raw types.Log // Blockchain specific contextual infos 3861 } 3862 3863 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 3864 // 3865 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 3866 func (_ERC20OnApprove *ERC20OnApproveFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*ERC20OnApproveTransferIterator, error) { 3867 3868 var fromRule []interface{} 3869 for _, fromItem := range from { 3870 fromRule = append(fromRule, fromItem) 3871 } 3872 var toRule []interface{} 3873 for _, toItem := range to { 3874 toRule = append(toRule, toItem) 3875 } 3876 3877 logs, sub, err := _ERC20OnApprove.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 3878 if err != nil { 3879 return nil, err 3880 } 3881 return &ERC20OnApproveTransferIterator{contract: _ERC20OnApprove.contract, event: "Transfer", logs: logs, sub: sub}, nil 3882 } 3883 3884 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 3885 // 3886 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 3887 func (_ERC20OnApprove *ERC20OnApproveFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *ERC20OnApproveTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 3888 3889 var fromRule []interface{} 3890 for _, fromItem := range from { 3891 fromRule = append(fromRule, fromItem) 3892 } 3893 var toRule []interface{} 3894 for _, toItem := range to { 3895 toRule = append(toRule, toItem) 3896 } 3897 3898 logs, sub, err := _ERC20OnApprove.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 3899 if err != nil { 3900 return nil, err 3901 } 3902 return event.NewSubscription(func(quit <-chan struct{}) error { 3903 defer sub.Unsubscribe() 3904 for { 3905 select { 3906 case log := <-logs: 3907 // New log arrived, parse the event and forward to the user 3908 event := new(ERC20OnApproveTransfer) 3909 if err := _ERC20OnApprove.contract.UnpackLog(event, "Transfer", log); err != nil { 3910 return err 3911 } 3912 event.Raw = log 3913 3914 select { 3915 case sink <- event: 3916 case err := <-sub.Err(): 3917 return err 3918 case <-quit: 3919 return nil 3920 } 3921 case err := <-sub.Err(): 3922 return err 3923 case <-quit: 3924 return nil 3925 } 3926 } 3927 }), nil 3928 } 3929 3930 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 3931 // 3932 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 3933 func (_ERC20OnApprove *ERC20OnApproveFilterer) ParseTransfer(log types.Log) (*ERC20OnApproveTransfer, error) { 3934 event := new(ERC20OnApproveTransfer) 3935 if err := _ERC20OnApprove.contract.UnpackLog(event, "Transfer", log); err != nil { 3936 return nil, err 3937 } 3938 return event, nil 3939 } 3940 3941 // IERC20ABI is the input ABI used to generate the binding from. 3942 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\"}]" 3943 3944 // IERC20FuncSigs maps the 4-byte function signature to its string representation. 3945 var IERC20FuncSigs = map[string]string{ 3946 "dd62ed3e": "allowance(address,address)", 3947 "095ea7b3": "approve(address,uint256)", 3948 "70a08231": "balanceOf(address)", 3949 "18160ddd": "totalSupply()", 3950 "a9059cbb": "transfer(address,uint256)", 3951 "23b872dd": "transferFrom(address,address,uint256)", 3952 } 3953 3954 // IERC20 is an auto generated Go binding around an Ethereum contract. 3955 type IERC20 struct { 3956 IERC20Caller // Read-only binding to the contract 3957 IERC20Transactor // Write-only binding to the contract 3958 IERC20Filterer // Log filterer for contract events 3959 } 3960 3961 // IERC20Caller is an auto generated read-only Go binding around an Ethereum contract. 3962 type IERC20Caller struct { 3963 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3964 } 3965 3966 // IERC20Transactor is an auto generated write-only Go binding around an Ethereum contract. 3967 type IERC20Transactor struct { 3968 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3969 } 3970 3971 // IERC20Filterer is an auto generated log filtering Go binding around an Ethereum contract events. 3972 type IERC20Filterer struct { 3973 contract *bind.BoundContract // Generic contract wrapper for the low level calls 3974 } 3975 3976 // IERC20Session is an auto generated Go binding around an Ethereum contract, 3977 // with pre-set call and transact options. 3978 type IERC20Session struct { 3979 Contract *IERC20 // Generic contract binding to set the session for 3980 CallOpts bind.CallOpts // Call options to use throughout this session 3981 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 3982 } 3983 3984 // IERC20CallerSession is an auto generated read-only Go binding around an Ethereum contract, 3985 // with pre-set call options. 3986 type IERC20CallerSession struct { 3987 Contract *IERC20Caller // Generic contract caller binding to set the session for 3988 CallOpts bind.CallOpts // Call options to use throughout this session 3989 } 3990 3991 // IERC20TransactorSession is an auto generated write-only Go binding around an Ethereum contract, 3992 // with pre-set transact options. 3993 type IERC20TransactorSession struct { 3994 Contract *IERC20Transactor // Generic contract transactor binding to set the session for 3995 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 3996 } 3997 3998 // IERC20Raw is an auto generated low-level Go binding around an Ethereum contract. 3999 type IERC20Raw struct { 4000 Contract *IERC20 // Generic contract binding to access the raw methods on 4001 } 4002 4003 // IERC20CallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 4004 type IERC20CallerRaw struct { 4005 Contract *IERC20Caller // Generic read-only contract binding to access the raw methods on 4006 } 4007 4008 // IERC20TransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 4009 type IERC20TransactorRaw struct { 4010 Contract *IERC20Transactor // Generic write-only contract binding to access the raw methods on 4011 } 4012 4013 // NewIERC20 creates a new instance of IERC20, bound to a specific deployed contract. 4014 func NewIERC20(address common.Address, backend bind.ContractBackend) (*IERC20, error) { 4015 contract, err := bindIERC20(address, backend, backend, backend) 4016 if err != nil { 4017 return nil, err 4018 } 4019 return &IERC20{IERC20Caller: IERC20Caller{contract: contract}, IERC20Transactor: IERC20Transactor{contract: contract}, IERC20Filterer: IERC20Filterer{contract: contract}}, nil 4020 } 4021 4022 // NewIERC20Caller creates a new read-only instance of IERC20, bound to a specific deployed contract. 4023 func NewIERC20Caller(address common.Address, caller bind.ContractCaller) (*IERC20Caller, error) { 4024 contract, err := bindIERC20(address, caller, nil, nil) 4025 if err != nil { 4026 return nil, err 4027 } 4028 return &IERC20Caller{contract: contract}, nil 4029 } 4030 4031 // NewIERC20Transactor creates a new write-only instance of IERC20, bound to a specific deployed contract. 4032 func NewIERC20Transactor(address common.Address, transactor bind.ContractTransactor) (*IERC20Transactor, error) { 4033 contract, err := bindIERC20(address, nil, transactor, nil) 4034 if err != nil { 4035 return nil, err 4036 } 4037 return &IERC20Transactor{contract: contract}, nil 4038 } 4039 4040 // NewIERC20Filterer creates a new log filterer instance of IERC20, bound to a specific deployed contract. 4041 func NewIERC20Filterer(address common.Address, filterer bind.ContractFilterer) (*IERC20Filterer, error) { 4042 contract, err := bindIERC20(address, nil, nil, filterer) 4043 if err != nil { 4044 return nil, err 4045 } 4046 return &IERC20Filterer{contract: contract}, nil 4047 } 4048 4049 // bindIERC20 binds a generic wrapper to an already deployed contract. 4050 func bindIERC20(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 4051 parsed, err := abi.JSON(strings.NewReader(IERC20ABI)) 4052 if err != nil { 4053 return nil, err 4054 } 4055 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 4056 } 4057 4058 // Call invokes the (constant) contract method with params as input values and 4059 // sets the output to result. The result type might be a single field for simple 4060 // returns, a slice of interfaces for anonymous returns and a struct for named 4061 // returns. 4062 func (_IERC20 *IERC20Raw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 4063 return _IERC20.Contract.IERC20Caller.contract.Call(opts, result, method, params...) 4064 } 4065 4066 // Transfer initiates a plain transaction to move funds to the contract, calling 4067 // its default method if one is available. 4068 func (_IERC20 *IERC20Raw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 4069 return _IERC20.Contract.IERC20Transactor.contract.Transfer(opts) 4070 } 4071 4072 // Transact invokes the (paid) contract method with params as input values. 4073 func (_IERC20 *IERC20Raw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 4074 return _IERC20.Contract.IERC20Transactor.contract.Transact(opts, method, params...) 4075 } 4076 4077 // Call invokes the (constant) contract method with params as input values and 4078 // sets the output to result. The result type might be a single field for simple 4079 // returns, a slice of interfaces for anonymous returns and a struct for named 4080 // returns. 4081 func (_IERC20 *IERC20CallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 4082 return _IERC20.Contract.contract.Call(opts, result, method, params...) 4083 } 4084 4085 // Transfer initiates a plain transaction to move funds to the contract, calling 4086 // its default method if one is available. 4087 func (_IERC20 *IERC20TransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 4088 return _IERC20.Contract.contract.Transfer(opts) 4089 } 4090 4091 // Transact invokes the (paid) contract method with params as input values. 4092 func (_IERC20 *IERC20TransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 4093 return _IERC20.Contract.contract.Transact(opts, method, params...) 4094 } 4095 4096 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 4097 // 4098 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 4099 func (_IERC20 *IERC20Caller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 4100 var ( 4101 ret0 = new(*big.Int) 4102 ) 4103 out := ret0 4104 err := _IERC20.contract.Call(opts, out, "allowance", owner, spender) 4105 return *ret0, err 4106 } 4107 4108 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 4109 // 4110 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 4111 func (_IERC20 *IERC20Session) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 4112 return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender) 4113 } 4114 4115 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 4116 // 4117 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 4118 func (_IERC20 *IERC20CallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 4119 return _IERC20.Contract.Allowance(&_IERC20.CallOpts, owner, spender) 4120 } 4121 4122 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 4123 // 4124 // Solidity: function balanceOf(address account) constant returns(uint256) 4125 func (_IERC20 *IERC20Caller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 4126 var ( 4127 ret0 = new(*big.Int) 4128 ) 4129 out := ret0 4130 err := _IERC20.contract.Call(opts, out, "balanceOf", account) 4131 return *ret0, err 4132 } 4133 4134 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 4135 // 4136 // Solidity: function balanceOf(address account) constant returns(uint256) 4137 func (_IERC20 *IERC20Session) BalanceOf(account common.Address) (*big.Int, error) { 4138 return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account) 4139 } 4140 4141 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 4142 // 4143 // Solidity: function balanceOf(address account) constant returns(uint256) 4144 func (_IERC20 *IERC20CallerSession) BalanceOf(account common.Address) (*big.Int, error) { 4145 return _IERC20.Contract.BalanceOf(&_IERC20.CallOpts, account) 4146 } 4147 4148 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 4149 // 4150 // Solidity: function totalSupply() constant returns(uint256) 4151 func (_IERC20 *IERC20Caller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 4152 var ( 4153 ret0 = new(*big.Int) 4154 ) 4155 out := ret0 4156 err := _IERC20.contract.Call(opts, out, "totalSupply") 4157 return *ret0, err 4158 } 4159 4160 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 4161 // 4162 // Solidity: function totalSupply() constant returns(uint256) 4163 func (_IERC20 *IERC20Session) TotalSupply() (*big.Int, error) { 4164 return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts) 4165 } 4166 4167 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 4168 // 4169 // Solidity: function totalSupply() constant returns(uint256) 4170 func (_IERC20 *IERC20CallerSession) TotalSupply() (*big.Int, error) { 4171 return _IERC20.Contract.TotalSupply(&_IERC20.CallOpts) 4172 } 4173 4174 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 4175 // 4176 // Solidity: function approve(address spender, uint256 amount) returns(bool) 4177 func (_IERC20 *IERC20Transactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 4178 return _IERC20.contract.Transact(opts, "approve", spender, amount) 4179 } 4180 4181 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 4182 // 4183 // Solidity: function approve(address spender, uint256 amount) returns(bool) 4184 func (_IERC20 *IERC20Session) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 4185 return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount) 4186 } 4187 4188 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 4189 // 4190 // Solidity: function approve(address spender, uint256 amount) returns(bool) 4191 func (_IERC20 *IERC20TransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 4192 return _IERC20.Contract.Approve(&_IERC20.TransactOpts, spender, amount) 4193 } 4194 4195 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 4196 // 4197 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 4198 func (_IERC20 *IERC20Transactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4199 return _IERC20.contract.Transact(opts, "transfer", recipient, amount) 4200 } 4201 4202 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 4203 // 4204 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 4205 func (_IERC20 *IERC20Session) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4206 return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, recipient, amount) 4207 } 4208 4209 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 4210 // 4211 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 4212 func (_IERC20 *IERC20TransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4213 return _IERC20.Contract.Transfer(&_IERC20.TransactOpts, recipient, amount) 4214 } 4215 4216 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 4217 // 4218 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 4219 func (_IERC20 *IERC20Transactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4220 return _IERC20.contract.Transact(opts, "transferFrom", sender, recipient, amount) 4221 } 4222 4223 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 4224 // 4225 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 4226 func (_IERC20 *IERC20Session) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4227 return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, sender, recipient, amount) 4228 } 4229 4230 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 4231 // 4232 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 4233 func (_IERC20 *IERC20TransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 4234 return _IERC20.Contract.TransferFrom(&_IERC20.TransactOpts, sender, recipient, amount) 4235 } 4236 4237 // 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. 4238 type IERC20ApprovalIterator struct { 4239 Event *IERC20Approval // Event containing the contract specifics and raw log 4240 4241 contract *bind.BoundContract // Generic contract to use for unpacking event data 4242 event string // Event name to use for unpacking event data 4243 4244 logs chan types.Log // Log channel receiving the found contract events 4245 sub ethereum.Subscription // Subscription for errors, completion and termination 4246 done bool // Whether the subscription completed delivering logs 4247 fail error // Occurred error to stop iteration 4248 } 4249 4250 // Next advances the iterator to the subsequent event, returning whether there 4251 // are any more events found. In case of a retrieval or parsing error, false is 4252 // returned and Error() can be queried for the exact failure. 4253 func (it *IERC20ApprovalIterator) Next() bool { 4254 // If the iterator failed, stop iterating 4255 if it.fail != nil { 4256 return false 4257 } 4258 // If the iterator completed, deliver directly whatever's available 4259 if it.done { 4260 select { 4261 case log := <-it.logs: 4262 it.Event = new(IERC20Approval) 4263 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4264 it.fail = err 4265 return false 4266 } 4267 it.Event.Raw = log 4268 return true 4269 4270 default: 4271 return false 4272 } 4273 } 4274 // Iterator still in progress, wait for either a data or an error event 4275 select { 4276 case log := <-it.logs: 4277 it.Event = new(IERC20Approval) 4278 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4279 it.fail = err 4280 return false 4281 } 4282 it.Event.Raw = log 4283 return true 4284 4285 case err := <-it.sub.Err(): 4286 it.done = true 4287 it.fail = err 4288 return it.Next() 4289 } 4290 } 4291 4292 // Error returns any retrieval or parsing error occurred during filtering. 4293 func (it *IERC20ApprovalIterator) Error() error { 4294 return it.fail 4295 } 4296 4297 // Close terminates the iteration process, releasing any pending underlying 4298 // resources. 4299 func (it *IERC20ApprovalIterator) Close() error { 4300 it.sub.Unsubscribe() 4301 return nil 4302 } 4303 4304 // IERC20Approval represents a Approval event raised by the IERC20 contract. 4305 type IERC20Approval struct { 4306 Owner common.Address 4307 Spender common.Address 4308 Value *big.Int 4309 Raw types.Log // Blockchain specific contextual infos 4310 } 4311 4312 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 4313 // 4314 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 4315 func (_IERC20 *IERC20Filterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*IERC20ApprovalIterator, error) { 4316 4317 var ownerRule []interface{} 4318 for _, ownerItem := range owner { 4319 ownerRule = append(ownerRule, ownerItem) 4320 } 4321 var spenderRule []interface{} 4322 for _, spenderItem := range spender { 4323 spenderRule = append(spenderRule, spenderItem) 4324 } 4325 4326 logs, sub, err := _IERC20.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 4327 if err != nil { 4328 return nil, err 4329 } 4330 return &IERC20ApprovalIterator{contract: _IERC20.contract, event: "Approval", logs: logs, sub: sub}, nil 4331 } 4332 4333 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 4334 // 4335 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 4336 func (_IERC20 *IERC20Filterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *IERC20Approval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 4337 4338 var ownerRule []interface{} 4339 for _, ownerItem := range owner { 4340 ownerRule = append(ownerRule, ownerItem) 4341 } 4342 var spenderRule []interface{} 4343 for _, spenderItem := range spender { 4344 spenderRule = append(spenderRule, spenderItem) 4345 } 4346 4347 logs, sub, err := _IERC20.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 4348 if err != nil { 4349 return nil, err 4350 } 4351 return event.NewSubscription(func(quit <-chan struct{}) error { 4352 defer sub.Unsubscribe() 4353 for { 4354 select { 4355 case log := <-logs: 4356 // New log arrived, parse the event and forward to the user 4357 event := new(IERC20Approval) 4358 if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil { 4359 return err 4360 } 4361 event.Raw = log 4362 4363 select { 4364 case sink <- event: 4365 case err := <-sub.Err(): 4366 return err 4367 case <-quit: 4368 return nil 4369 } 4370 case err := <-sub.Err(): 4371 return err 4372 case <-quit: 4373 return nil 4374 } 4375 } 4376 }), nil 4377 } 4378 4379 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 4380 // 4381 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 4382 func (_IERC20 *IERC20Filterer) ParseApproval(log types.Log) (*IERC20Approval, error) { 4383 event := new(IERC20Approval) 4384 if err := _IERC20.contract.UnpackLog(event, "Approval", log); err != nil { 4385 return nil, err 4386 } 4387 return event, nil 4388 } 4389 4390 // 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. 4391 type IERC20TransferIterator struct { 4392 Event *IERC20Transfer // Event containing the contract specifics and raw log 4393 4394 contract *bind.BoundContract // Generic contract to use for unpacking event data 4395 event string // Event name to use for unpacking event data 4396 4397 logs chan types.Log // Log channel receiving the found contract events 4398 sub ethereum.Subscription // Subscription for errors, completion and termination 4399 done bool // Whether the subscription completed delivering logs 4400 fail error // Occurred error to stop iteration 4401 } 4402 4403 // Next advances the iterator to the subsequent event, returning whether there 4404 // are any more events found. In case of a retrieval or parsing error, false is 4405 // returned and Error() can be queried for the exact failure. 4406 func (it *IERC20TransferIterator) Next() bool { 4407 // If the iterator failed, stop iterating 4408 if it.fail != nil { 4409 return false 4410 } 4411 // If the iterator completed, deliver directly whatever's available 4412 if it.done { 4413 select { 4414 case log := <-it.logs: 4415 it.Event = new(IERC20Transfer) 4416 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4417 it.fail = err 4418 return false 4419 } 4420 it.Event.Raw = log 4421 return true 4422 4423 default: 4424 return false 4425 } 4426 } 4427 // Iterator still in progress, wait for either a data or an error event 4428 select { 4429 case log := <-it.logs: 4430 it.Event = new(IERC20Transfer) 4431 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4432 it.fail = err 4433 return false 4434 } 4435 it.Event.Raw = log 4436 return true 4437 4438 case err := <-it.sub.Err(): 4439 it.done = true 4440 it.fail = err 4441 return it.Next() 4442 } 4443 } 4444 4445 // Error returns any retrieval or parsing error occurred during filtering. 4446 func (it *IERC20TransferIterator) Error() error { 4447 return it.fail 4448 } 4449 4450 // Close terminates the iteration process, releasing any pending underlying 4451 // resources. 4452 func (it *IERC20TransferIterator) Close() error { 4453 it.sub.Unsubscribe() 4454 return nil 4455 } 4456 4457 // IERC20Transfer represents a Transfer event raised by the IERC20 contract. 4458 type IERC20Transfer struct { 4459 From common.Address 4460 To common.Address 4461 Value *big.Int 4462 Raw types.Log // Blockchain specific contextual infos 4463 } 4464 4465 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 4466 // 4467 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 4468 func (_IERC20 *IERC20Filterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*IERC20TransferIterator, error) { 4469 4470 var fromRule []interface{} 4471 for _, fromItem := range from { 4472 fromRule = append(fromRule, fromItem) 4473 } 4474 var toRule []interface{} 4475 for _, toItem := range to { 4476 toRule = append(toRule, toItem) 4477 } 4478 4479 logs, sub, err := _IERC20.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 4480 if err != nil { 4481 return nil, err 4482 } 4483 return &IERC20TransferIterator{contract: _IERC20.contract, event: "Transfer", logs: logs, sub: sub}, nil 4484 } 4485 4486 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 4487 // 4488 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 4489 func (_IERC20 *IERC20Filterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *IERC20Transfer, from []common.Address, to []common.Address) (event.Subscription, error) { 4490 4491 var fromRule []interface{} 4492 for _, fromItem := range from { 4493 fromRule = append(fromRule, fromItem) 4494 } 4495 var toRule []interface{} 4496 for _, toItem := range to { 4497 toRule = append(toRule, toItem) 4498 } 4499 4500 logs, sub, err := _IERC20.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 4501 if err != nil { 4502 return nil, err 4503 } 4504 return event.NewSubscription(func(quit <-chan struct{}) error { 4505 defer sub.Unsubscribe() 4506 for { 4507 select { 4508 case log := <-logs: 4509 // New log arrived, parse the event and forward to the user 4510 event := new(IERC20Transfer) 4511 if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil { 4512 return err 4513 } 4514 event.Raw = log 4515 4516 select { 4517 case sink <- event: 4518 case err := <-sub.Err(): 4519 return err 4520 case <-quit: 4521 return nil 4522 } 4523 case err := <-sub.Err(): 4524 return err 4525 case <-quit: 4526 return nil 4527 } 4528 } 4529 }), nil 4530 } 4531 4532 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 4533 // 4534 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 4535 func (_IERC20 *IERC20Filterer) ParseTransfer(log types.Log) (*IERC20Transfer, error) { 4536 event := new(IERC20Transfer) 4537 if err := _IERC20.contract.UnpackLog(event, "Transfer", log); err != nil { 4538 return nil, err 4539 } 4540 return event, nil 4541 } 4542 4543 // MinterRoleABI is the input ABI used to generate the binding from. 4544 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\"}]" 4545 4546 // MinterRoleFuncSigs maps the 4-byte function signature to its string representation. 4547 var MinterRoleFuncSigs = map[string]string{ 4548 "983b2d56": "addMinter(address)", 4549 "aa271e1a": "isMinter(address)", 4550 "98650275": "renounceMinter()", 4551 } 4552 4553 // MinterRole is an auto generated Go binding around an Ethereum contract. 4554 type MinterRole struct { 4555 MinterRoleCaller // Read-only binding to the contract 4556 MinterRoleTransactor // Write-only binding to the contract 4557 MinterRoleFilterer // Log filterer for contract events 4558 } 4559 4560 // MinterRoleCaller is an auto generated read-only Go binding around an Ethereum contract. 4561 type MinterRoleCaller struct { 4562 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4563 } 4564 4565 // MinterRoleTransactor is an auto generated write-only Go binding around an Ethereum contract. 4566 type MinterRoleTransactor struct { 4567 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4568 } 4569 4570 // MinterRoleFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 4571 type MinterRoleFilterer struct { 4572 contract *bind.BoundContract // Generic contract wrapper for the low level calls 4573 } 4574 4575 // MinterRoleSession is an auto generated Go binding around an Ethereum contract, 4576 // with pre-set call and transact options. 4577 type MinterRoleSession struct { 4578 Contract *MinterRole // Generic contract binding to set the session for 4579 CallOpts bind.CallOpts // Call options to use throughout this session 4580 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 4581 } 4582 4583 // MinterRoleCallerSession is an auto generated read-only Go binding around an Ethereum contract, 4584 // with pre-set call options. 4585 type MinterRoleCallerSession struct { 4586 Contract *MinterRoleCaller // Generic contract caller binding to set the session for 4587 CallOpts bind.CallOpts // Call options to use throughout this session 4588 } 4589 4590 // MinterRoleTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 4591 // with pre-set transact options. 4592 type MinterRoleTransactorSession struct { 4593 Contract *MinterRoleTransactor // Generic contract transactor binding to set the session for 4594 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 4595 } 4596 4597 // MinterRoleRaw is an auto generated low-level Go binding around an Ethereum contract. 4598 type MinterRoleRaw struct { 4599 Contract *MinterRole // Generic contract binding to access the raw methods on 4600 } 4601 4602 // MinterRoleCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 4603 type MinterRoleCallerRaw struct { 4604 Contract *MinterRoleCaller // Generic read-only contract binding to access the raw methods on 4605 } 4606 4607 // MinterRoleTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 4608 type MinterRoleTransactorRaw struct { 4609 Contract *MinterRoleTransactor // Generic write-only contract binding to access the raw methods on 4610 } 4611 4612 // NewMinterRole creates a new instance of MinterRole, bound to a specific deployed contract. 4613 func NewMinterRole(address common.Address, backend bind.ContractBackend) (*MinterRole, error) { 4614 contract, err := bindMinterRole(address, backend, backend, backend) 4615 if err != nil { 4616 return nil, err 4617 } 4618 return &MinterRole{MinterRoleCaller: MinterRoleCaller{contract: contract}, MinterRoleTransactor: MinterRoleTransactor{contract: contract}, MinterRoleFilterer: MinterRoleFilterer{contract: contract}}, nil 4619 } 4620 4621 // NewMinterRoleCaller creates a new read-only instance of MinterRole, bound to a specific deployed contract. 4622 func NewMinterRoleCaller(address common.Address, caller bind.ContractCaller) (*MinterRoleCaller, error) { 4623 contract, err := bindMinterRole(address, caller, nil, nil) 4624 if err != nil { 4625 return nil, err 4626 } 4627 return &MinterRoleCaller{contract: contract}, nil 4628 } 4629 4630 // NewMinterRoleTransactor creates a new write-only instance of MinterRole, bound to a specific deployed contract. 4631 func NewMinterRoleTransactor(address common.Address, transactor bind.ContractTransactor) (*MinterRoleTransactor, error) { 4632 contract, err := bindMinterRole(address, nil, transactor, nil) 4633 if err != nil { 4634 return nil, err 4635 } 4636 return &MinterRoleTransactor{contract: contract}, nil 4637 } 4638 4639 // NewMinterRoleFilterer creates a new log filterer instance of MinterRole, bound to a specific deployed contract. 4640 func NewMinterRoleFilterer(address common.Address, filterer bind.ContractFilterer) (*MinterRoleFilterer, error) { 4641 contract, err := bindMinterRole(address, nil, nil, filterer) 4642 if err != nil { 4643 return nil, err 4644 } 4645 return &MinterRoleFilterer{contract: contract}, nil 4646 } 4647 4648 // bindMinterRole binds a generic wrapper to an already deployed contract. 4649 func bindMinterRole(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 4650 parsed, err := abi.JSON(strings.NewReader(MinterRoleABI)) 4651 if err != nil { 4652 return nil, err 4653 } 4654 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 4655 } 4656 4657 // Call invokes the (constant) contract method with params as input values and 4658 // sets the output to result. The result type might be a single field for simple 4659 // returns, a slice of interfaces for anonymous returns and a struct for named 4660 // returns. 4661 func (_MinterRole *MinterRoleRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 4662 return _MinterRole.Contract.MinterRoleCaller.contract.Call(opts, result, method, params...) 4663 } 4664 4665 // Transfer initiates a plain transaction to move funds to the contract, calling 4666 // its default method if one is available. 4667 func (_MinterRole *MinterRoleRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 4668 return _MinterRole.Contract.MinterRoleTransactor.contract.Transfer(opts) 4669 } 4670 4671 // Transact invokes the (paid) contract method with params as input values. 4672 func (_MinterRole *MinterRoleRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 4673 return _MinterRole.Contract.MinterRoleTransactor.contract.Transact(opts, method, params...) 4674 } 4675 4676 // Call invokes the (constant) contract method with params as input values and 4677 // sets the output to result. The result type might be a single field for simple 4678 // returns, a slice of interfaces for anonymous returns and a struct for named 4679 // returns. 4680 func (_MinterRole *MinterRoleCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 4681 return _MinterRole.Contract.contract.Call(opts, result, method, params...) 4682 } 4683 4684 // Transfer initiates a plain transaction to move funds to the contract, calling 4685 // its default method if one is available. 4686 func (_MinterRole *MinterRoleTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 4687 return _MinterRole.Contract.contract.Transfer(opts) 4688 } 4689 4690 // Transact invokes the (paid) contract method with params as input values. 4691 func (_MinterRole *MinterRoleTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 4692 return _MinterRole.Contract.contract.Transact(opts, method, params...) 4693 } 4694 4695 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 4696 // 4697 // Solidity: function isMinter(address account) constant returns(bool) 4698 func (_MinterRole *MinterRoleCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) { 4699 var ( 4700 ret0 = new(bool) 4701 ) 4702 out := ret0 4703 err := _MinterRole.contract.Call(opts, out, "isMinter", account) 4704 return *ret0, err 4705 } 4706 4707 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 4708 // 4709 // Solidity: function isMinter(address account) constant returns(bool) 4710 func (_MinterRole *MinterRoleSession) IsMinter(account common.Address) (bool, error) { 4711 return _MinterRole.Contract.IsMinter(&_MinterRole.CallOpts, account) 4712 } 4713 4714 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 4715 // 4716 // Solidity: function isMinter(address account) constant returns(bool) 4717 func (_MinterRole *MinterRoleCallerSession) IsMinter(account common.Address) (bool, error) { 4718 return _MinterRole.Contract.IsMinter(&_MinterRole.CallOpts, account) 4719 } 4720 4721 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 4722 // 4723 // Solidity: function addMinter(address account) returns() 4724 func (_MinterRole *MinterRoleTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) { 4725 return _MinterRole.contract.Transact(opts, "addMinter", account) 4726 } 4727 4728 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 4729 // 4730 // Solidity: function addMinter(address account) returns() 4731 func (_MinterRole *MinterRoleSession) AddMinter(account common.Address) (*types.Transaction, error) { 4732 return _MinterRole.Contract.AddMinter(&_MinterRole.TransactOpts, account) 4733 } 4734 4735 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 4736 // 4737 // Solidity: function addMinter(address account) returns() 4738 func (_MinterRole *MinterRoleTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) { 4739 return _MinterRole.Contract.AddMinter(&_MinterRole.TransactOpts, account) 4740 } 4741 4742 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 4743 // 4744 // Solidity: function renounceMinter() returns() 4745 func (_MinterRole *MinterRoleTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) { 4746 return _MinterRole.contract.Transact(opts, "renounceMinter") 4747 } 4748 4749 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 4750 // 4751 // Solidity: function renounceMinter() returns() 4752 func (_MinterRole *MinterRoleSession) RenounceMinter() (*types.Transaction, error) { 4753 return _MinterRole.Contract.RenounceMinter(&_MinterRole.TransactOpts) 4754 } 4755 4756 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 4757 // 4758 // Solidity: function renounceMinter() returns() 4759 func (_MinterRole *MinterRoleTransactorSession) RenounceMinter() (*types.Transaction, error) { 4760 return _MinterRole.Contract.RenounceMinter(&_MinterRole.TransactOpts) 4761 } 4762 4763 // 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. 4764 type MinterRoleMinterAddedIterator struct { 4765 Event *MinterRoleMinterAdded // Event containing the contract specifics and raw log 4766 4767 contract *bind.BoundContract // Generic contract to use for unpacking event data 4768 event string // Event name to use for unpacking event data 4769 4770 logs chan types.Log // Log channel receiving the found contract events 4771 sub ethereum.Subscription // Subscription for errors, completion and termination 4772 done bool // Whether the subscription completed delivering logs 4773 fail error // Occurred error to stop iteration 4774 } 4775 4776 // Next advances the iterator to the subsequent event, returning whether there 4777 // are any more events found. In case of a retrieval or parsing error, false is 4778 // returned and Error() can be queried for the exact failure. 4779 func (it *MinterRoleMinterAddedIterator) Next() bool { 4780 // If the iterator failed, stop iterating 4781 if it.fail != nil { 4782 return false 4783 } 4784 // If the iterator completed, deliver directly whatever's available 4785 if it.done { 4786 select { 4787 case log := <-it.logs: 4788 it.Event = new(MinterRoleMinterAdded) 4789 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4790 it.fail = err 4791 return false 4792 } 4793 it.Event.Raw = log 4794 return true 4795 4796 default: 4797 return false 4798 } 4799 } 4800 // Iterator still in progress, wait for either a data or an error event 4801 select { 4802 case log := <-it.logs: 4803 it.Event = new(MinterRoleMinterAdded) 4804 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4805 it.fail = err 4806 return false 4807 } 4808 it.Event.Raw = log 4809 return true 4810 4811 case err := <-it.sub.Err(): 4812 it.done = true 4813 it.fail = err 4814 return it.Next() 4815 } 4816 } 4817 4818 // Error returns any retrieval or parsing error occurred during filtering. 4819 func (it *MinterRoleMinterAddedIterator) Error() error { 4820 return it.fail 4821 } 4822 4823 // Close terminates the iteration process, releasing any pending underlying 4824 // resources. 4825 func (it *MinterRoleMinterAddedIterator) Close() error { 4826 it.sub.Unsubscribe() 4827 return nil 4828 } 4829 4830 // MinterRoleMinterAdded represents a MinterAdded event raised by the MinterRole contract. 4831 type MinterRoleMinterAdded struct { 4832 Account common.Address 4833 Raw types.Log // Blockchain specific contextual infos 4834 } 4835 4836 // FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 4837 // 4838 // Solidity: event MinterAdded(address indexed account) 4839 func (_MinterRole *MinterRoleFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterAddedIterator, error) { 4840 4841 var accountRule []interface{} 4842 for _, accountItem := range account { 4843 accountRule = append(accountRule, accountItem) 4844 } 4845 4846 logs, sub, err := _MinterRole.contract.FilterLogs(opts, "MinterAdded", accountRule) 4847 if err != nil { 4848 return nil, err 4849 } 4850 return &MinterRoleMinterAddedIterator{contract: _MinterRole.contract, event: "MinterAdded", logs: logs, sub: sub}, nil 4851 } 4852 4853 // WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 4854 // 4855 // Solidity: event MinterAdded(address indexed account) 4856 func (_MinterRole *MinterRoleFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterAdded, account []common.Address) (event.Subscription, error) { 4857 4858 var accountRule []interface{} 4859 for _, accountItem := range account { 4860 accountRule = append(accountRule, accountItem) 4861 } 4862 4863 logs, sub, err := _MinterRole.contract.WatchLogs(opts, "MinterAdded", accountRule) 4864 if err != nil { 4865 return nil, err 4866 } 4867 return event.NewSubscription(func(quit <-chan struct{}) error { 4868 defer sub.Unsubscribe() 4869 for { 4870 select { 4871 case log := <-logs: 4872 // New log arrived, parse the event and forward to the user 4873 event := new(MinterRoleMinterAdded) 4874 if err := _MinterRole.contract.UnpackLog(event, "MinterAdded", log); err != nil { 4875 return err 4876 } 4877 event.Raw = log 4878 4879 select { 4880 case sink <- event: 4881 case err := <-sub.Err(): 4882 return err 4883 case <-quit: 4884 return nil 4885 } 4886 case err := <-sub.Err(): 4887 return err 4888 case <-quit: 4889 return nil 4890 } 4891 } 4892 }), nil 4893 } 4894 4895 // ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 4896 // 4897 // Solidity: event MinterAdded(address indexed account) 4898 func (_MinterRole *MinterRoleFilterer) ParseMinterAdded(log types.Log) (*MinterRoleMinterAdded, error) { 4899 event := new(MinterRoleMinterAdded) 4900 if err := _MinterRole.contract.UnpackLog(event, "MinterAdded", log); err != nil { 4901 return nil, err 4902 } 4903 return event, nil 4904 } 4905 4906 // 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. 4907 type MinterRoleMinterRemovedIterator struct { 4908 Event *MinterRoleMinterRemoved // Event containing the contract specifics and raw log 4909 4910 contract *bind.BoundContract // Generic contract to use for unpacking event data 4911 event string // Event name to use for unpacking event data 4912 4913 logs chan types.Log // Log channel receiving the found contract events 4914 sub ethereum.Subscription // Subscription for errors, completion and termination 4915 done bool // Whether the subscription completed delivering logs 4916 fail error // Occurred error to stop iteration 4917 } 4918 4919 // Next advances the iterator to the subsequent event, returning whether there 4920 // are any more events found. In case of a retrieval or parsing error, false is 4921 // returned and Error() can be queried for the exact failure. 4922 func (it *MinterRoleMinterRemovedIterator) Next() bool { 4923 // If the iterator failed, stop iterating 4924 if it.fail != nil { 4925 return false 4926 } 4927 // If the iterator completed, deliver directly whatever's available 4928 if it.done { 4929 select { 4930 case log := <-it.logs: 4931 it.Event = new(MinterRoleMinterRemoved) 4932 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4933 it.fail = err 4934 return false 4935 } 4936 it.Event.Raw = log 4937 return true 4938 4939 default: 4940 return false 4941 } 4942 } 4943 // Iterator still in progress, wait for either a data or an error event 4944 select { 4945 case log := <-it.logs: 4946 it.Event = new(MinterRoleMinterRemoved) 4947 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 4948 it.fail = err 4949 return false 4950 } 4951 it.Event.Raw = log 4952 return true 4953 4954 case err := <-it.sub.Err(): 4955 it.done = true 4956 it.fail = err 4957 return it.Next() 4958 } 4959 } 4960 4961 // Error returns any retrieval or parsing error occurred during filtering. 4962 func (it *MinterRoleMinterRemovedIterator) Error() error { 4963 return it.fail 4964 } 4965 4966 // Close terminates the iteration process, releasing any pending underlying 4967 // resources. 4968 func (it *MinterRoleMinterRemovedIterator) Close() error { 4969 it.sub.Unsubscribe() 4970 return nil 4971 } 4972 4973 // MinterRoleMinterRemoved represents a MinterRemoved event raised by the MinterRole contract. 4974 type MinterRoleMinterRemoved struct { 4975 Account common.Address 4976 Raw types.Log // Blockchain specific contextual infos 4977 } 4978 4979 // FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 4980 // 4981 // Solidity: event MinterRemoved(address indexed account) 4982 func (_MinterRole *MinterRoleFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*MinterRoleMinterRemovedIterator, error) { 4983 4984 var accountRule []interface{} 4985 for _, accountItem := range account { 4986 accountRule = append(accountRule, accountItem) 4987 } 4988 4989 logs, sub, err := _MinterRole.contract.FilterLogs(opts, "MinterRemoved", accountRule) 4990 if err != nil { 4991 return nil, err 4992 } 4993 return &MinterRoleMinterRemovedIterator{contract: _MinterRole.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil 4994 } 4995 4996 // WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 4997 // 4998 // Solidity: event MinterRemoved(address indexed account) 4999 func (_MinterRole *MinterRoleFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *MinterRoleMinterRemoved, account []common.Address) (event.Subscription, error) { 5000 5001 var accountRule []interface{} 5002 for _, accountItem := range account { 5003 accountRule = append(accountRule, accountItem) 5004 } 5005 5006 logs, sub, err := _MinterRole.contract.WatchLogs(opts, "MinterRemoved", accountRule) 5007 if err != nil { 5008 return nil, err 5009 } 5010 return event.NewSubscription(func(quit <-chan struct{}) error { 5011 defer sub.Unsubscribe() 5012 for { 5013 select { 5014 case log := <-logs: 5015 // New log arrived, parse the event and forward to the user 5016 event := new(MinterRoleMinterRemoved) 5017 if err := _MinterRole.contract.UnpackLog(event, "MinterRemoved", log); err != nil { 5018 return err 5019 } 5020 event.Raw = log 5021 5022 select { 5023 case sink <- event: 5024 case err := <-sub.Err(): 5025 return err 5026 case <-quit: 5027 return nil 5028 } 5029 case err := <-sub.Err(): 5030 return err 5031 case <-quit: 5032 return nil 5033 } 5034 } 5035 }), nil 5036 } 5037 5038 // ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 5039 // 5040 // Solidity: event MinterRemoved(address indexed account) 5041 func (_MinterRole *MinterRoleFilterer) ParseMinterRemoved(log types.Log) (*MinterRoleMinterRemoved, error) { 5042 event := new(MinterRoleMinterRemoved) 5043 if err := _MinterRole.contract.UnpackLog(event, "MinterRemoved", log); err != nil { 5044 return nil, err 5045 } 5046 return event, nil 5047 } 5048 5049 // MinterRoleRenounceTargetABI is the input ABI used to generate the binding from. 5050 const MinterRoleRenounceTargetABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"renounceMinter\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 5051 5052 // MinterRoleRenounceTargetFuncSigs maps the 4-byte function signature to its string representation. 5053 var MinterRoleRenounceTargetFuncSigs = map[string]string{ 5054 "98650275": "renounceMinter()", 5055 } 5056 5057 // MinterRoleRenounceTarget is an auto generated Go binding around an Ethereum contract. 5058 type MinterRoleRenounceTarget struct { 5059 MinterRoleRenounceTargetCaller // Read-only binding to the contract 5060 MinterRoleRenounceTargetTransactor // Write-only binding to the contract 5061 MinterRoleRenounceTargetFilterer // Log filterer for contract events 5062 } 5063 5064 // MinterRoleRenounceTargetCaller is an auto generated read-only Go binding around an Ethereum contract. 5065 type MinterRoleRenounceTargetCaller struct { 5066 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5067 } 5068 5069 // MinterRoleRenounceTargetTransactor is an auto generated write-only Go binding around an Ethereum contract. 5070 type MinterRoleRenounceTargetTransactor struct { 5071 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5072 } 5073 5074 // MinterRoleRenounceTargetFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 5075 type MinterRoleRenounceTargetFilterer struct { 5076 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5077 } 5078 5079 // MinterRoleRenounceTargetSession is an auto generated Go binding around an Ethereum contract, 5080 // with pre-set call and transact options. 5081 type MinterRoleRenounceTargetSession struct { 5082 Contract *MinterRoleRenounceTarget // Generic contract binding to set the session for 5083 CallOpts bind.CallOpts // Call options to use throughout this session 5084 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 5085 } 5086 5087 // MinterRoleRenounceTargetCallerSession is an auto generated read-only Go binding around an Ethereum contract, 5088 // with pre-set call options. 5089 type MinterRoleRenounceTargetCallerSession struct { 5090 Contract *MinterRoleRenounceTargetCaller // Generic contract caller binding to set the session for 5091 CallOpts bind.CallOpts // Call options to use throughout this session 5092 } 5093 5094 // MinterRoleRenounceTargetTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 5095 // with pre-set transact options. 5096 type MinterRoleRenounceTargetTransactorSession struct { 5097 Contract *MinterRoleRenounceTargetTransactor // Generic contract transactor binding to set the session for 5098 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 5099 } 5100 5101 // MinterRoleRenounceTargetRaw is an auto generated low-level Go binding around an Ethereum contract. 5102 type MinterRoleRenounceTargetRaw struct { 5103 Contract *MinterRoleRenounceTarget // Generic contract binding to access the raw methods on 5104 } 5105 5106 // MinterRoleRenounceTargetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 5107 type MinterRoleRenounceTargetCallerRaw struct { 5108 Contract *MinterRoleRenounceTargetCaller // Generic read-only contract binding to access the raw methods on 5109 } 5110 5111 // MinterRoleRenounceTargetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 5112 type MinterRoleRenounceTargetTransactorRaw struct { 5113 Contract *MinterRoleRenounceTargetTransactor // Generic write-only contract binding to access the raw methods on 5114 } 5115 5116 // NewMinterRoleRenounceTarget creates a new instance of MinterRoleRenounceTarget, bound to a specific deployed contract. 5117 func NewMinterRoleRenounceTarget(address common.Address, backend bind.ContractBackend) (*MinterRoleRenounceTarget, error) { 5118 contract, err := bindMinterRoleRenounceTarget(address, backend, backend, backend) 5119 if err != nil { 5120 return nil, err 5121 } 5122 return &MinterRoleRenounceTarget{MinterRoleRenounceTargetCaller: MinterRoleRenounceTargetCaller{contract: contract}, MinterRoleRenounceTargetTransactor: MinterRoleRenounceTargetTransactor{contract: contract}, MinterRoleRenounceTargetFilterer: MinterRoleRenounceTargetFilterer{contract: contract}}, nil 5123 } 5124 5125 // NewMinterRoleRenounceTargetCaller creates a new read-only instance of MinterRoleRenounceTarget, bound to a specific deployed contract. 5126 func NewMinterRoleRenounceTargetCaller(address common.Address, caller bind.ContractCaller) (*MinterRoleRenounceTargetCaller, error) { 5127 contract, err := bindMinterRoleRenounceTarget(address, caller, nil, nil) 5128 if err != nil { 5129 return nil, err 5130 } 5131 return &MinterRoleRenounceTargetCaller{contract: contract}, nil 5132 } 5133 5134 // NewMinterRoleRenounceTargetTransactor creates a new write-only instance of MinterRoleRenounceTarget, bound to a specific deployed contract. 5135 func NewMinterRoleRenounceTargetTransactor(address common.Address, transactor bind.ContractTransactor) (*MinterRoleRenounceTargetTransactor, error) { 5136 contract, err := bindMinterRoleRenounceTarget(address, nil, transactor, nil) 5137 if err != nil { 5138 return nil, err 5139 } 5140 return &MinterRoleRenounceTargetTransactor{contract: contract}, nil 5141 } 5142 5143 // NewMinterRoleRenounceTargetFilterer creates a new log filterer instance of MinterRoleRenounceTarget, bound to a specific deployed contract. 5144 func NewMinterRoleRenounceTargetFilterer(address common.Address, filterer bind.ContractFilterer) (*MinterRoleRenounceTargetFilterer, error) { 5145 contract, err := bindMinterRoleRenounceTarget(address, nil, nil, filterer) 5146 if err != nil { 5147 return nil, err 5148 } 5149 return &MinterRoleRenounceTargetFilterer{contract: contract}, nil 5150 } 5151 5152 // bindMinterRoleRenounceTarget binds a generic wrapper to an already deployed contract. 5153 func bindMinterRoleRenounceTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 5154 parsed, err := abi.JSON(strings.NewReader(MinterRoleRenounceTargetABI)) 5155 if err != nil { 5156 return nil, err 5157 } 5158 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 5159 } 5160 5161 // Call invokes the (constant) contract method with params as input values and 5162 // sets the output to result. The result type might be a single field for simple 5163 // returns, a slice of interfaces for anonymous returns and a struct for named 5164 // returns. 5165 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 5166 return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetCaller.contract.Call(opts, result, method, params...) 5167 } 5168 5169 // Transfer initiates a plain transaction to move funds to the contract, calling 5170 // its default method if one is available. 5171 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 5172 return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetTransactor.contract.Transfer(opts) 5173 } 5174 5175 // Transact invokes the (paid) contract method with params as input values. 5176 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 5177 return _MinterRoleRenounceTarget.Contract.MinterRoleRenounceTargetTransactor.contract.Transact(opts, method, params...) 5178 } 5179 5180 // Call invokes the (constant) contract method with params as input values and 5181 // sets the output to result. The result type might be a single field for simple 5182 // returns, a slice of interfaces for anonymous returns and a struct for named 5183 // returns. 5184 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 5185 return _MinterRoleRenounceTarget.Contract.contract.Call(opts, result, method, params...) 5186 } 5187 5188 // Transfer initiates a plain transaction to move funds to the contract, calling 5189 // its default method if one is available. 5190 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 5191 return _MinterRoleRenounceTarget.Contract.contract.Transfer(opts) 5192 } 5193 5194 // Transact invokes the (paid) contract method with params as input values. 5195 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 5196 return _MinterRoleRenounceTarget.Contract.contract.Transact(opts, method, params...) 5197 } 5198 5199 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 5200 // 5201 // Solidity: function renounceMinter() returns() 5202 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactor) RenounceMinter(opts *bind.TransactOpts) (*types.Transaction, error) { 5203 return _MinterRoleRenounceTarget.contract.Transact(opts, "renounceMinter") 5204 } 5205 5206 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 5207 // 5208 // Solidity: function renounceMinter() returns() 5209 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetSession) RenounceMinter() (*types.Transaction, error) { 5210 return _MinterRoleRenounceTarget.Contract.RenounceMinter(&_MinterRoleRenounceTarget.TransactOpts) 5211 } 5212 5213 // RenounceMinter is a paid mutator transaction binding the contract method 0x98650275. 5214 // 5215 // Solidity: function renounceMinter() returns() 5216 func (_MinterRoleRenounceTarget *MinterRoleRenounceTargetTransactorSession) RenounceMinter() (*types.Transaction, error) { 5217 return _MinterRoleRenounceTarget.Contract.RenounceMinter(&_MinterRoleRenounceTarget.TransactOpts) 5218 } 5219 5220 // OnApproveConstantABI is the input ABI used to generate the binding from. 5221 const OnApproveConstantABI = "[{\"constant\":true,\"inputs\":[],\"name\":\"INTERFACE_ID_ON_APPROVE\",\"outputs\":[{\"internalType\":\"bytes4\",\"name\":\"\",\"type\":\"bytes4\"}],\"payable\":false,\"stateMutability\":\"view\",\"type\":\"function\"}]" 5222 5223 // OnApproveConstantFuncSigs maps the 4-byte function signature to its string representation. 5224 var OnApproveConstantFuncSigs = map[string]string{ 5225 "6cd28f9a": "INTERFACE_ID_ON_APPROVE()", 5226 } 5227 5228 // OnApproveConstantBin is the compiled bytecode used for deploying new contracts. 5229 var OnApproveConstantBin = "0x6080604052348015600f57600080fd5b5060c78061001e6000396000f3fe6080604052348015600f57600080fd5b506004361060285760003560e01c80636cd28f9a14602d575b600080fd5b60336050565b604080516001600160e01b03199092168252519081900360200190f35b604051806028606b8239602801905060405180910390208156fe6f6e417070726f766528616464726573732c616464726573732c75696e743235362c627974657329a265627a7a723158206d94182e39f46cad6425154650e56ecd40259e07a64364bd131e67fe91c85c7664736f6c634300050c0032" 5230 5231 // DeployOnApproveConstant deploys a new Ethereum contract, binding an instance of OnApproveConstant to it. 5232 func DeployOnApproveConstant(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *OnApproveConstant, error) { 5233 parsed, err := abi.JSON(strings.NewReader(OnApproveConstantABI)) 5234 if err != nil { 5235 return common.Address{}, nil, nil, err 5236 } 5237 5238 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(OnApproveConstantBin), backend) 5239 if err != nil { 5240 return common.Address{}, nil, nil, err 5241 } 5242 return address, tx, &OnApproveConstant{OnApproveConstantCaller: OnApproveConstantCaller{contract: contract}, OnApproveConstantTransactor: OnApproveConstantTransactor{contract: contract}, OnApproveConstantFilterer: OnApproveConstantFilterer{contract: contract}}, nil 5243 } 5244 5245 // OnApproveConstant is an auto generated Go binding around an Ethereum contract. 5246 type OnApproveConstant struct { 5247 OnApproveConstantCaller // Read-only binding to the contract 5248 OnApproveConstantTransactor // Write-only binding to the contract 5249 OnApproveConstantFilterer // Log filterer for contract events 5250 } 5251 5252 // OnApproveConstantCaller is an auto generated read-only Go binding around an Ethereum contract. 5253 type OnApproveConstantCaller struct { 5254 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5255 } 5256 5257 // OnApproveConstantTransactor is an auto generated write-only Go binding around an Ethereum contract. 5258 type OnApproveConstantTransactor struct { 5259 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5260 } 5261 5262 // OnApproveConstantFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 5263 type OnApproveConstantFilterer struct { 5264 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5265 } 5266 5267 // OnApproveConstantSession is an auto generated Go binding around an Ethereum contract, 5268 // with pre-set call and transact options. 5269 type OnApproveConstantSession struct { 5270 Contract *OnApproveConstant // Generic contract binding to set the session for 5271 CallOpts bind.CallOpts // Call options to use throughout this session 5272 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 5273 } 5274 5275 // OnApproveConstantCallerSession is an auto generated read-only Go binding around an Ethereum contract, 5276 // with pre-set call options. 5277 type OnApproveConstantCallerSession struct { 5278 Contract *OnApproveConstantCaller // Generic contract caller binding to set the session for 5279 CallOpts bind.CallOpts // Call options to use throughout this session 5280 } 5281 5282 // OnApproveConstantTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 5283 // with pre-set transact options. 5284 type OnApproveConstantTransactorSession struct { 5285 Contract *OnApproveConstantTransactor // Generic contract transactor binding to set the session for 5286 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 5287 } 5288 5289 // OnApproveConstantRaw is an auto generated low-level Go binding around an Ethereum contract. 5290 type OnApproveConstantRaw struct { 5291 Contract *OnApproveConstant // Generic contract binding to access the raw methods on 5292 } 5293 5294 // OnApproveConstantCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 5295 type OnApproveConstantCallerRaw struct { 5296 Contract *OnApproveConstantCaller // Generic read-only contract binding to access the raw methods on 5297 } 5298 5299 // OnApproveConstantTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 5300 type OnApproveConstantTransactorRaw struct { 5301 Contract *OnApproveConstantTransactor // Generic write-only contract binding to access the raw methods on 5302 } 5303 5304 // NewOnApproveConstant creates a new instance of OnApproveConstant, bound to a specific deployed contract. 5305 func NewOnApproveConstant(address common.Address, backend bind.ContractBackend) (*OnApproveConstant, error) { 5306 contract, err := bindOnApproveConstant(address, backend, backend, backend) 5307 if err != nil { 5308 return nil, err 5309 } 5310 return &OnApproveConstant{OnApproveConstantCaller: OnApproveConstantCaller{contract: contract}, OnApproveConstantTransactor: OnApproveConstantTransactor{contract: contract}, OnApproveConstantFilterer: OnApproveConstantFilterer{contract: contract}}, nil 5311 } 5312 5313 // NewOnApproveConstantCaller creates a new read-only instance of OnApproveConstant, bound to a specific deployed contract. 5314 func NewOnApproveConstantCaller(address common.Address, caller bind.ContractCaller) (*OnApproveConstantCaller, error) { 5315 contract, err := bindOnApproveConstant(address, caller, nil, nil) 5316 if err != nil { 5317 return nil, err 5318 } 5319 return &OnApproveConstantCaller{contract: contract}, nil 5320 } 5321 5322 // NewOnApproveConstantTransactor creates a new write-only instance of OnApproveConstant, bound to a specific deployed contract. 5323 func NewOnApproveConstantTransactor(address common.Address, transactor bind.ContractTransactor) (*OnApproveConstantTransactor, error) { 5324 contract, err := bindOnApproveConstant(address, nil, transactor, nil) 5325 if err != nil { 5326 return nil, err 5327 } 5328 return &OnApproveConstantTransactor{contract: contract}, nil 5329 } 5330 5331 // NewOnApproveConstantFilterer creates a new log filterer instance of OnApproveConstant, bound to a specific deployed contract. 5332 func NewOnApproveConstantFilterer(address common.Address, filterer bind.ContractFilterer) (*OnApproveConstantFilterer, error) { 5333 contract, err := bindOnApproveConstant(address, nil, nil, filterer) 5334 if err != nil { 5335 return nil, err 5336 } 5337 return &OnApproveConstantFilterer{contract: contract}, nil 5338 } 5339 5340 // bindOnApproveConstant binds a generic wrapper to an already deployed contract. 5341 func bindOnApproveConstant(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 5342 parsed, err := abi.JSON(strings.NewReader(OnApproveConstantABI)) 5343 if err != nil { 5344 return nil, err 5345 } 5346 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 5347 } 5348 5349 // Call invokes the (constant) contract method with params as input values and 5350 // sets the output to result. The result type might be a single field for simple 5351 // returns, a slice of interfaces for anonymous returns and a struct for named 5352 // returns. 5353 func (_OnApproveConstant *OnApproveConstantRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 5354 return _OnApproveConstant.Contract.OnApproveConstantCaller.contract.Call(opts, result, method, params...) 5355 } 5356 5357 // Transfer initiates a plain transaction to move funds to the contract, calling 5358 // its default method if one is available. 5359 func (_OnApproveConstant *OnApproveConstantRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 5360 return _OnApproveConstant.Contract.OnApproveConstantTransactor.contract.Transfer(opts) 5361 } 5362 5363 // Transact invokes the (paid) contract method with params as input values. 5364 func (_OnApproveConstant *OnApproveConstantRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 5365 return _OnApproveConstant.Contract.OnApproveConstantTransactor.contract.Transact(opts, method, params...) 5366 } 5367 5368 // Call invokes the (constant) contract method with params as input values and 5369 // sets the output to result. The result type might be a single field for simple 5370 // returns, a slice of interfaces for anonymous returns and a struct for named 5371 // returns. 5372 func (_OnApproveConstant *OnApproveConstantCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 5373 return _OnApproveConstant.Contract.contract.Call(opts, result, method, params...) 5374 } 5375 5376 // Transfer initiates a plain transaction to move funds to the contract, calling 5377 // its default method if one is available. 5378 func (_OnApproveConstant *OnApproveConstantTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 5379 return _OnApproveConstant.Contract.contract.Transfer(opts) 5380 } 5381 5382 // Transact invokes the (paid) contract method with params as input values. 5383 func (_OnApproveConstant *OnApproveConstantTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 5384 return _OnApproveConstant.Contract.contract.Transact(opts, method, params...) 5385 } 5386 5387 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 5388 // 5389 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 5390 func (_OnApproveConstant *OnApproveConstantCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) { 5391 var ( 5392 ret0 = new([4]byte) 5393 ) 5394 out := ret0 5395 err := _OnApproveConstant.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE") 5396 return *ret0, err 5397 } 5398 5399 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 5400 // 5401 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 5402 func (_OnApproveConstant *OnApproveConstantSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 5403 return _OnApproveConstant.Contract.INTERFACEIDONAPPROVE(&_OnApproveConstant.CallOpts) 5404 } 5405 5406 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 5407 // 5408 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 5409 func (_OnApproveConstant *OnApproveConstantCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 5410 return _OnApproveConstant.Contract.INTERFACEIDONAPPROVE(&_OnApproveConstant.CallOpts) 5411 } 5412 5413 // OwnableABI is the input ABI used to generate the binding from. 5414 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\"}]" 5415 5416 // OwnableFuncSigs maps the 4-byte function signature to its string representation. 5417 var OwnableFuncSigs = map[string]string{ 5418 "8f32d59b": "isOwner()", 5419 "8da5cb5b": "owner()", 5420 "715018a6": "renounceOwnership()", 5421 "f2fde38b": "transferOwnership(address)", 5422 } 5423 5424 // Ownable is an auto generated Go binding around an Ethereum contract. 5425 type Ownable struct { 5426 OwnableCaller // Read-only binding to the contract 5427 OwnableTransactor // Write-only binding to the contract 5428 OwnableFilterer // Log filterer for contract events 5429 } 5430 5431 // OwnableCaller is an auto generated read-only Go binding around an Ethereum contract. 5432 type OwnableCaller struct { 5433 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5434 } 5435 5436 // OwnableTransactor is an auto generated write-only Go binding around an Ethereum contract. 5437 type OwnableTransactor struct { 5438 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5439 } 5440 5441 // OwnableFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 5442 type OwnableFilterer struct { 5443 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5444 } 5445 5446 // OwnableSession is an auto generated Go binding around an Ethereum contract, 5447 // with pre-set call and transact options. 5448 type OwnableSession struct { 5449 Contract *Ownable // Generic contract binding to set the session for 5450 CallOpts bind.CallOpts // Call options to use throughout this session 5451 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 5452 } 5453 5454 // OwnableCallerSession is an auto generated read-only Go binding around an Ethereum contract, 5455 // with pre-set call options. 5456 type OwnableCallerSession struct { 5457 Contract *OwnableCaller // Generic contract caller binding to set the session for 5458 CallOpts bind.CallOpts // Call options to use throughout this session 5459 } 5460 5461 // OwnableTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 5462 // with pre-set transact options. 5463 type OwnableTransactorSession struct { 5464 Contract *OwnableTransactor // Generic contract transactor binding to set the session for 5465 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 5466 } 5467 5468 // OwnableRaw is an auto generated low-level Go binding around an Ethereum contract. 5469 type OwnableRaw struct { 5470 Contract *Ownable // Generic contract binding to access the raw methods on 5471 } 5472 5473 // OwnableCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 5474 type OwnableCallerRaw struct { 5475 Contract *OwnableCaller // Generic read-only contract binding to access the raw methods on 5476 } 5477 5478 // OwnableTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 5479 type OwnableTransactorRaw struct { 5480 Contract *OwnableTransactor // Generic write-only contract binding to access the raw methods on 5481 } 5482 5483 // NewOwnable creates a new instance of Ownable, bound to a specific deployed contract. 5484 func NewOwnable(address common.Address, backend bind.ContractBackend) (*Ownable, error) { 5485 contract, err := bindOwnable(address, backend, backend, backend) 5486 if err != nil { 5487 return nil, err 5488 } 5489 return &Ownable{OwnableCaller: OwnableCaller{contract: contract}, OwnableTransactor: OwnableTransactor{contract: contract}, OwnableFilterer: OwnableFilterer{contract: contract}}, nil 5490 } 5491 5492 // NewOwnableCaller creates a new read-only instance of Ownable, bound to a specific deployed contract. 5493 func NewOwnableCaller(address common.Address, caller bind.ContractCaller) (*OwnableCaller, error) { 5494 contract, err := bindOwnable(address, caller, nil, nil) 5495 if err != nil { 5496 return nil, err 5497 } 5498 return &OwnableCaller{contract: contract}, nil 5499 } 5500 5501 // NewOwnableTransactor creates a new write-only instance of Ownable, bound to a specific deployed contract. 5502 func NewOwnableTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTransactor, error) { 5503 contract, err := bindOwnable(address, nil, transactor, nil) 5504 if err != nil { 5505 return nil, err 5506 } 5507 return &OwnableTransactor{contract: contract}, nil 5508 } 5509 5510 // NewOwnableFilterer creates a new log filterer instance of Ownable, bound to a specific deployed contract. 5511 func NewOwnableFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableFilterer, error) { 5512 contract, err := bindOwnable(address, nil, nil, filterer) 5513 if err != nil { 5514 return nil, err 5515 } 5516 return &OwnableFilterer{contract: contract}, nil 5517 } 5518 5519 // bindOwnable binds a generic wrapper to an already deployed contract. 5520 func bindOwnable(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 5521 parsed, err := abi.JSON(strings.NewReader(OwnableABI)) 5522 if err != nil { 5523 return nil, err 5524 } 5525 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 5526 } 5527 5528 // Call invokes the (constant) contract method with params as input values and 5529 // sets the output to result. The result type might be a single field for simple 5530 // returns, a slice of interfaces for anonymous returns and a struct for named 5531 // returns. 5532 func (_Ownable *OwnableRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 5533 return _Ownable.Contract.OwnableCaller.contract.Call(opts, result, method, params...) 5534 } 5535 5536 // Transfer initiates a plain transaction to move funds to the contract, calling 5537 // its default method if one is available. 5538 func (_Ownable *OwnableRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 5539 return _Ownable.Contract.OwnableTransactor.contract.Transfer(opts) 5540 } 5541 5542 // Transact invokes the (paid) contract method with params as input values. 5543 func (_Ownable *OwnableRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 5544 return _Ownable.Contract.OwnableTransactor.contract.Transact(opts, method, params...) 5545 } 5546 5547 // Call invokes the (constant) contract method with params as input values and 5548 // sets the output to result. The result type might be a single field for simple 5549 // returns, a slice of interfaces for anonymous returns and a struct for named 5550 // returns. 5551 func (_Ownable *OwnableCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 5552 return _Ownable.Contract.contract.Call(opts, result, method, params...) 5553 } 5554 5555 // Transfer initiates a plain transaction to move funds to the contract, calling 5556 // its default method if one is available. 5557 func (_Ownable *OwnableTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 5558 return _Ownable.Contract.contract.Transfer(opts) 5559 } 5560 5561 // Transact invokes the (paid) contract method with params as input values. 5562 func (_Ownable *OwnableTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 5563 return _Ownable.Contract.contract.Transact(opts, method, params...) 5564 } 5565 5566 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 5567 // 5568 // Solidity: function isOwner() constant returns(bool) 5569 func (_Ownable *OwnableCaller) IsOwner(opts *bind.CallOpts) (bool, error) { 5570 var ( 5571 ret0 = new(bool) 5572 ) 5573 out := ret0 5574 err := _Ownable.contract.Call(opts, out, "isOwner") 5575 return *ret0, err 5576 } 5577 5578 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 5579 // 5580 // Solidity: function isOwner() constant returns(bool) 5581 func (_Ownable *OwnableSession) IsOwner() (bool, error) { 5582 return _Ownable.Contract.IsOwner(&_Ownable.CallOpts) 5583 } 5584 5585 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 5586 // 5587 // Solidity: function isOwner() constant returns(bool) 5588 func (_Ownable *OwnableCallerSession) IsOwner() (bool, error) { 5589 return _Ownable.Contract.IsOwner(&_Ownable.CallOpts) 5590 } 5591 5592 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 5593 // 5594 // Solidity: function owner() constant returns(address) 5595 func (_Ownable *OwnableCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 5596 var ( 5597 ret0 = new(common.Address) 5598 ) 5599 out := ret0 5600 err := _Ownable.contract.Call(opts, out, "owner") 5601 return *ret0, err 5602 } 5603 5604 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 5605 // 5606 // Solidity: function owner() constant returns(address) 5607 func (_Ownable *OwnableSession) Owner() (common.Address, error) { 5608 return _Ownable.Contract.Owner(&_Ownable.CallOpts) 5609 } 5610 5611 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 5612 // 5613 // Solidity: function owner() constant returns(address) 5614 func (_Ownable *OwnableCallerSession) Owner() (common.Address, error) { 5615 return _Ownable.Contract.Owner(&_Ownable.CallOpts) 5616 } 5617 5618 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 5619 // 5620 // Solidity: function renounceOwnership() returns() 5621 func (_Ownable *OwnableTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { 5622 return _Ownable.contract.Transact(opts, "renounceOwnership") 5623 } 5624 5625 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 5626 // 5627 // Solidity: function renounceOwnership() returns() 5628 func (_Ownable *OwnableSession) RenounceOwnership() (*types.Transaction, error) { 5629 return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts) 5630 } 5631 5632 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 5633 // 5634 // Solidity: function renounceOwnership() returns() 5635 func (_Ownable *OwnableTransactorSession) RenounceOwnership() (*types.Transaction, error) { 5636 return _Ownable.Contract.RenounceOwnership(&_Ownable.TransactOpts) 5637 } 5638 5639 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 5640 // 5641 // Solidity: function transferOwnership(address newOwner) returns() 5642 func (_Ownable *OwnableTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 5643 return _Ownable.contract.Transact(opts, "transferOwnership", newOwner) 5644 } 5645 5646 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 5647 // 5648 // Solidity: function transferOwnership(address newOwner) returns() 5649 func (_Ownable *OwnableSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 5650 return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner) 5651 } 5652 5653 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 5654 // 5655 // Solidity: function transferOwnership(address newOwner) returns() 5656 func (_Ownable *OwnableTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 5657 return _Ownable.Contract.TransferOwnership(&_Ownable.TransactOpts, newOwner) 5658 } 5659 5660 // 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. 5661 type OwnableOwnershipTransferredIterator struct { 5662 Event *OwnableOwnershipTransferred // Event containing the contract specifics and raw log 5663 5664 contract *bind.BoundContract // Generic contract to use for unpacking event data 5665 event string // Event name to use for unpacking event data 5666 5667 logs chan types.Log // Log channel receiving the found contract events 5668 sub ethereum.Subscription // Subscription for errors, completion and termination 5669 done bool // Whether the subscription completed delivering logs 5670 fail error // Occurred error to stop iteration 5671 } 5672 5673 // Next advances the iterator to the subsequent event, returning whether there 5674 // are any more events found. In case of a retrieval or parsing error, false is 5675 // returned and Error() can be queried for the exact failure. 5676 func (it *OwnableOwnershipTransferredIterator) Next() bool { 5677 // If the iterator failed, stop iterating 5678 if it.fail != nil { 5679 return false 5680 } 5681 // If the iterator completed, deliver directly whatever's available 5682 if it.done { 5683 select { 5684 case log := <-it.logs: 5685 it.Event = new(OwnableOwnershipTransferred) 5686 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 5687 it.fail = err 5688 return false 5689 } 5690 it.Event.Raw = log 5691 return true 5692 5693 default: 5694 return false 5695 } 5696 } 5697 // Iterator still in progress, wait for either a data or an error event 5698 select { 5699 case log := <-it.logs: 5700 it.Event = new(OwnableOwnershipTransferred) 5701 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 5702 it.fail = err 5703 return false 5704 } 5705 it.Event.Raw = log 5706 return true 5707 5708 case err := <-it.sub.Err(): 5709 it.done = true 5710 it.fail = err 5711 return it.Next() 5712 } 5713 } 5714 5715 // Error returns any retrieval or parsing error occurred during filtering. 5716 func (it *OwnableOwnershipTransferredIterator) Error() error { 5717 return it.fail 5718 } 5719 5720 // Close terminates the iteration process, releasing any pending underlying 5721 // resources. 5722 func (it *OwnableOwnershipTransferredIterator) Close() error { 5723 it.sub.Unsubscribe() 5724 return nil 5725 } 5726 5727 // OwnableOwnershipTransferred represents a OwnershipTransferred event raised by the Ownable contract. 5728 type OwnableOwnershipTransferred struct { 5729 PreviousOwner common.Address 5730 NewOwner common.Address 5731 Raw types.Log // Blockchain specific contextual infos 5732 } 5733 5734 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 5735 // 5736 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 5737 func (_Ownable *OwnableFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*OwnableOwnershipTransferredIterator, error) { 5738 5739 var previousOwnerRule []interface{} 5740 for _, previousOwnerItem := range previousOwner { 5741 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 5742 } 5743 var newOwnerRule []interface{} 5744 for _, newOwnerItem := range newOwner { 5745 newOwnerRule = append(newOwnerRule, newOwnerItem) 5746 } 5747 5748 logs, sub, err := _Ownable.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 5749 if err != nil { 5750 return nil, err 5751 } 5752 return &OwnableOwnershipTransferredIterator{contract: _Ownable.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 5753 } 5754 5755 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 5756 // 5757 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 5758 func (_Ownable *OwnableFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *OwnableOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 5759 5760 var previousOwnerRule []interface{} 5761 for _, previousOwnerItem := range previousOwner { 5762 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 5763 } 5764 var newOwnerRule []interface{} 5765 for _, newOwnerItem := range newOwner { 5766 newOwnerRule = append(newOwnerRule, newOwnerItem) 5767 } 5768 5769 logs, sub, err := _Ownable.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 5770 if err != nil { 5771 return nil, err 5772 } 5773 return event.NewSubscription(func(quit <-chan struct{}) error { 5774 defer sub.Unsubscribe() 5775 for { 5776 select { 5777 case log := <-logs: 5778 // New log arrived, parse the event and forward to the user 5779 event := new(OwnableOwnershipTransferred) 5780 if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 5781 return err 5782 } 5783 event.Raw = log 5784 5785 select { 5786 case sink <- event: 5787 case err := <-sub.Err(): 5788 return err 5789 case <-quit: 5790 return nil 5791 } 5792 case err := <-sub.Err(): 5793 return err 5794 case <-quit: 5795 return nil 5796 } 5797 } 5798 }), nil 5799 } 5800 5801 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 5802 // 5803 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 5804 func (_Ownable *OwnableFilterer) ParseOwnershipTransferred(log types.Log) (*OwnableOwnershipTransferred, error) { 5805 event := new(OwnableOwnershipTransferred) 5806 if err := _Ownable.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 5807 return nil, err 5808 } 5809 return event, nil 5810 } 5811 5812 // OwnableTargetABI is the input ABI used to generate the binding from. 5813 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\"}]" 5814 5815 // OwnableTargetFuncSigs maps the 4-byte function signature to its string representation. 5816 var OwnableTargetFuncSigs = map[string]string{ 5817 "715018a6": "renounceOwnership()", 5818 "f2fde38b": "transferOwnership(address)", 5819 } 5820 5821 // OwnableTarget is an auto generated Go binding around an Ethereum contract. 5822 type OwnableTarget struct { 5823 OwnableTargetCaller // Read-only binding to the contract 5824 OwnableTargetTransactor // Write-only binding to the contract 5825 OwnableTargetFilterer // Log filterer for contract events 5826 } 5827 5828 // OwnableTargetCaller is an auto generated read-only Go binding around an Ethereum contract. 5829 type OwnableTargetCaller struct { 5830 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5831 } 5832 5833 // OwnableTargetTransactor is an auto generated write-only Go binding around an Ethereum contract. 5834 type OwnableTargetTransactor struct { 5835 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5836 } 5837 5838 // OwnableTargetFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 5839 type OwnableTargetFilterer struct { 5840 contract *bind.BoundContract // Generic contract wrapper for the low level calls 5841 } 5842 5843 // OwnableTargetSession is an auto generated Go binding around an Ethereum contract, 5844 // with pre-set call and transact options. 5845 type OwnableTargetSession struct { 5846 Contract *OwnableTarget // Generic contract binding to set the session for 5847 CallOpts bind.CallOpts // Call options to use throughout this session 5848 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 5849 } 5850 5851 // OwnableTargetCallerSession is an auto generated read-only Go binding around an Ethereum contract, 5852 // with pre-set call options. 5853 type OwnableTargetCallerSession struct { 5854 Contract *OwnableTargetCaller // Generic contract caller binding to set the session for 5855 CallOpts bind.CallOpts // Call options to use throughout this session 5856 } 5857 5858 // OwnableTargetTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 5859 // with pre-set transact options. 5860 type OwnableTargetTransactorSession struct { 5861 Contract *OwnableTargetTransactor // Generic contract transactor binding to set the session for 5862 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 5863 } 5864 5865 // OwnableTargetRaw is an auto generated low-level Go binding around an Ethereum contract. 5866 type OwnableTargetRaw struct { 5867 Contract *OwnableTarget // Generic contract binding to access the raw methods on 5868 } 5869 5870 // OwnableTargetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 5871 type OwnableTargetCallerRaw struct { 5872 Contract *OwnableTargetCaller // Generic read-only contract binding to access the raw methods on 5873 } 5874 5875 // OwnableTargetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 5876 type OwnableTargetTransactorRaw struct { 5877 Contract *OwnableTargetTransactor // Generic write-only contract binding to access the raw methods on 5878 } 5879 5880 // NewOwnableTarget creates a new instance of OwnableTarget, bound to a specific deployed contract. 5881 func NewOwnableTarget(address common.Address, backend bind.ContractBackend) (*OwnableTarget, error) { 5882 contract, err := bindOwnableTarget(address, backend, backend, backend) 5883 if err != nil { 5884 return nil, err 5885 } 5886 return &OwnableTarget{OwnableTargetCaller: OwnableTargetCaller{contract: contract}, OwnableTargetTransactor: OwnableTargetTransactor{contract: contract}, OwnableTargetFilterer: OwnableTargetFilterer{contract: contract}}, nil 5887 } 5888 5889 // NewOwnableTargetCaller creates a new read-only instance of OwnableTarget, bound to a specific deployed contract. 5890 func NewOwnableTargetCaller(address common.Address, caller bind.ContractCaller) (*OwnableTargetCaller, error) { 5891 contract, err := bindOwnableTarget(address, caller, nil, nil) 5892 if err != nil { 5893 return nil, err 5894 } 5895 return &OwnableTargetCaller{contract: contract}, nil 5896 } 5897 5898 // NewOwnableTargetTransactor creates a new write-only instance of OwnableTarget, bound to a specific deployed contract. 5899 func NewOwnableTargetTransactor(address common.Address, transactor bind.ContractTransactor) (*OwnableTargetTransactor, error) { 5900 contract, err := bindOwnableTarget(address, nil, transactor, nil) 5901 if err != nil { 5902 return nil, err 5903 } 5904 return &OwnableTargetTransactor{contract: contract}, nil 5905 } 5906 5907 // NewOwnableTargetFilterer creates a new log filterer instance of OwnableTarget, bound to a specific deployed contract. 5908 func NewOwnableTargetFilterer(address common.Address, filterer bind.ContractFilterer) (*OwnableTargetFilterer, error) { 5909 contract, err := bindOwnableTarget(address, nil, nil, filterer) 5910 if err != nil { 5911 return nil, err 5912 } 5913 return &OwnableTargetFilterer{contract: contract}, nil 5914 } 5915 5916 // bindOwnableTarget binds a generic wrapper to an already deployed contract. 5917 func bindOwnableTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 5918 parsed, err := abi.JSON(strings.NewReader(OwnableTargetABI)) 5919 if err != nil { 5920 return nil, err 5921 } 5922 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 5923 } 5924 5925 // Call invokes the (constant) contract method with params as input values and 5926 // sets the output to result. The result type might be a single field for simple 5927 // returns, a slice of interfaces for anonymous returns and a struct for named 5928 // returns. 5929 func (_OwnableTarget *OwnableTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 5930 return _OwnableTarget.Contract.OwnableTargetCaller.contract.Call(opts, result, method, params...) 5931 } 5932 5933 // Transfer initiates a plain transaction to move funds to the contract, calling 5934 // its default method if one is available. 5935 func (_OwnableTarget *OwnableTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 5936 return _OwnableTarget.Contract.OwnableTargetTransactor.contract.Transfer(opts) 5937 } 5938 5939 // Transact invokes the (paid) contract method with params as input values. 5940 func (_OwnableTarget *OwnableTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 5941 return _OwnableTarget.Contract.OwnableTargetTransactor.contract.Transact(opts, method, params...) 5942 } 5943 5944 // Call invokes the (constant) contract method with params as input values and 5945 // sets the output to result. The result type might be a single field for simple 5946 // returns, a slice of interfaces for anonymous returns and a struct for named 5947 // returns. 5948 func (_OwnableTarget *OwnableTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 5949 return _OwnableTarget.Contract.contract.Call(opts, result, method, params...) 5950 } 5951 5952 // Transfer initiates a plain transaction to move funds to the contract, calling 5953 // its default method if one is available. 5954 func (_OwnableTarget *OwnableTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 5955 return _OwnableTarget.Contract.contract.Transfer(opts) 5956 } 5957 5958 // Transact invokes the (paid) contract method with params as input values. 5959 func (_OwnableTarget *OwnableTargetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 5960 return _OwnableTarget.Contract.contract.Transact(opts, method, params...) 5961 } 5962 5963 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 5964 // 5965 // Solidity: function renounceOwnership() returns() 5966 func (_OwnableTarget *OwnableTargetTransactor) RenounceOwnership(opts *bind.TransactOpts) (*types.Transaction, error) { 5967 return _OwnableTarget.contract.Transact(opts, "renounceOwnership") 5968 } 5969 5970 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 5971 // 5972 // Solidity: function renounceOwnership() returns() 5973 func (_OwnableTarget *OwnableTargetSession) RenounceOwnership() (*types.Transaction, error) { 5974 return _OwnableTarget.Contract.RenounceOwnership(&_OwnableTarget.TransactOpts) 5975 } 5976 5977 // RenounceOwnership is a paid mutator transaction binding the contract method 0x715018a6. 5978 // 5979 // Solidity: function renounceOwnership() returns() 5980 func (_OwnableTarget *OwnableTargetTransactorSession) RenounceOwnership() (*types.Transaction, error) { 5981 return _OwnableTarget.Contract.RenounceOwnership(&_OwnableTarget.TransactOpts) 5982 } 5983 5984 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 5985 // 5986 // Solidity: function transferOwnership(address newOwner) returns() 5987 func (_OwnableTarget *OwnableTargetTransactor) TransferOwnership(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 5988 return _OwnableTarget.contract.Transact(opts, "transferOwnership", newOwner) 5989 } 5990 5991 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 5992 // 5993 // Solidity: function transferOwnership(address newOwner) returns() 5994 func (_OwnableTarget *OwnableTargetSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 5995 return _OwnableTarget.Contract.TransferOwnership(&_OwnableTarget.TransactOpts, newOwner) 5996 } 5997 5998 // TransferOwnership is a paid mutator transaction binding the contract method 0xf2fde38b. 5999 // 6000 // Solidity: function transferOwnership(address newOwner) returns() 6001 func (_OwnableTarget *OwnableTargetTransactorSession) TransferOwnership(newOwner common.Address) (*types.Transaction, error) { 6002 return _OwnableTarget.Contract.TransferOwnership(&_OwnableTarget.TransactOpts, newOwner) 6003 } 6004 6005 // PauserRoleRenounceTargetABI is the input ABI used to generate the binding from. 6006 const PauserRoleRenounceTargetABI = "[{\"constant\":false,\"inputs\":[],\"name\":\"renouncePauser\",\"outputs\":[],\"payable\":false,\"stateMutability\":\"nonpayable\",\"type\":\"function\"}]" 6007 6008 // PauserRoleRenounceTargetFuncSigs maps the 4-byte function signature to its string representation. 6009 var PauserRoleRenounceTargetFuncSigs = map[string]string{ 6010 "6ef8d66d": "renouncePauser()", 6011 } 6012 6013 // PauserRoleRenounceTarget is an auto generated Go binding around an Ethereum contract. 6014 type PauserRoleRenounceTarget struct { 6015 PauserRoleRenounceTargetCaller // Read-only binding to the contract 6016 PauserRoleRenounceTargetTransactor // Write-only binding to the contract 6017 PauserRoleRenounceTargetFilterer // Log filterer for contract events 6018 } 6019 6020 // PauserRoleRenounceTargetCaller is an auto generated read-only Go binding around an Ethereum contract. 6021 type PauserRoleRenounceTargetCaller struct { 6022 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6023 } 6024 6025 // PauserRoleRenounceTargetTransactor is an auto generated write-only Go binding around an Ethereum contract. 6026 type PauserRoleRenounceTargetTransactor struct { 6027 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6028 } 6029 6030 // PauserRoleRenounceTargetFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 6031 type PauserRoleRenounceTargetFilterer struct { 6032 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6033 } 6034 6035 // PauserRoleRenounceTargetSession is an auto generated Go binding around an Ethereum contract, 6036 // with pre-set call and transact options. 6037 type PauserRoleRenounceTargetSession struct { 6038 Contract *PauserRoleRenounceTarget // Generic contract binding to set the session for 6039 CallOpts bind.CallOpts // Call options to use throughout this session 6040 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 6041 } 6042 6043 // PauserRoleRenounceTargetCallerSession is an auto generated read-only Go binding around an Ethereum contract, 6044 // with pre-set call options. 6045 type PauserRoleRenounceTargetCallerSession struct { 6046 Contract *PauserRoleRenounceTargetCaller // Generic contract caller binding to set the session for 6047 CallOpts bind.CallOpts // Call options to use throughout this session 6048 } 6049 6050 // PauserRoleRenounceTargetTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 6051 // with pre-set transact options. 6052 type PauserRoleRenounceTargetTransactorSession struct { 6053 Contract *PauserRoleRenounceTargetTransactor // Generic contract transactor binding to set the session for 6054 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 6055 } 6056 6057 // PauserRoleRenounceTargetRaw is an auto generated low-level Go binding around an Ethereum contract. 6058 type PauserRoleRenounceTargetRaw struct { 6059 Contract *PauserRoleRenounceTarget // Generic contract binding to access the raw methods on 6060 } 6061 6062 // PauserRoleRenounceTargetCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 6063 type PauserRoleRenounceTargetCallerRaw struct { 6064 Contract *PauserRoleRenounceTargetCaller // Generic read-only contract binding to access the raw methods on 6065 } 6066 6067 // PauserRoleRenounceTargetTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 6068 type PauserRoleRenounceTargetTransactorRaw struct { 6069 Contract *PauserRoleRenounceTargetTransactor // Generic write-only contract binding to access the raw methods on 6070 } 6071 6072 // NewPauserRoleRenounceTarget creates a new instance of PauserRoleRenounceTarget, bound to a specific deployed contract. 6073 func NewPauserRoleRenounceTarget(address common.Address, backend bind.ContractBackend) (*PauserRoleRenounceTarget, error) { 6074 contract, err := bindPauserRoleRenounceTarget(address, backend, backend, backend) 6075 if err != nil { 6076 return nil, err 6077 } 6078 return &PauserRoleRenounceTarget{PauserRoleRenounceTargetCaller: PauserRoleRenounceTargetCaller{contract: contract}, PauserRoleRenounceTargetTransactor: PauserRoleRenounceTargetTransactor{contract: contract}, PauserRoleRenounceTargetFilterer: PauserRoleRenounceTargetFilterer{contract: contract}}, nil 6079 } 6080 6081 // NewPauserRoleRenounceTargetCaller creates a new read-only instance of PauserRoleRenounceTarget, bound to a specific deployed contract. 6082 func NewPauserRoleRenounceTargetCaller(address common.Address, caller bind.ContractCaller) (*PauserRoleRenounceTargetCaller, error) { 6083 contract, err := bindPauserRoleRenounceTarget(address, caller, nil, nil) 6084 if err != nil { 6085 return nil, err 6086 } 6087 return &PauserRoleRenounceTargetCaller{contract: contract}, nil 6088 } 6089 6090 // NewPauserRoleRenounceTargetTransactor creates a new write-only instance of PauserRoleRenounceTarget, bound to a specific deployed contract. 6091 func NewPauserRoleRenounceTargetTransactor(address common.Address, transactor bind.ContractTransactor) (*PauserRoleRenounceTargetTransactor, error) { 6092 contract, err := bindPauserRoleRenounceTarget(address, nil, transactor, nil) 6093 if err != nil { 6094 return nil, err 6095 } 6096 return &PauserRoleRenounceTargetTransactor{contract: contract}, nil 6097 } 6098 6099 // NewPauserRoleRenounceTargetFilterer creates a new log filterer instance of PauserRoleRenounceTarget, bound to a specific deployed contract. 6100 func NewPauserRoleRenounceTargetFilterer(address common.Address, filterer bind.ContractFilterer) (*PauserRoleRenounceTargetFilterer, error) { 6101 contract, err := bindPauserRoleRenounceTarget(address, nil, nil, filterer) 6102 if err != nil { 6103 return nil, err 6104 } 6105 return &PauserRoleRenounceTargetFilterer{contract: contract}, nil 6106 } 6107 6108 // bindPauserRoleRenounceTarget binds a generic wrapper to an already deployed contract. 6109 func bindPauserRoleRenounceTarget(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 6110 parsed, err := abi.JSON(strings.NewReader(PauserRoleRenounceTargetABI)) 6111 if err != nil { 6112 return nil, err 6113 } 6114 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 6115 } 6116 6117 // Call invokes the (constant) contract method with params as input values and 6118 // sets the output to result. The result type might be a single field for simple 6119 // returns, a slice of interfaces for anonymous returns and a struct for named 6120 // returns. 6121 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 6122 return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetCaller.contract.Call(opts, result, method, params...) 6123 } 6124 6125 // Transfer initiates a plain transaction to move funds to the contract, calling 6126 // its default method if one is available. 6127 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 6128 return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetTransactor.contract.Transfer(opts) 6129 } 6130 6131 // Transact invokes the (paid) contract method with params as input values. 6132 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 6133 return _PauserRoleRenounceTarget.Contract.PauserRoleRenounceTargetTransactor.contract.Transact(opts, method, params...) 6134 } 6135 6136 // Call invokes the (constant) contract method with params as input values and 6137 // sets the output to result. The result type might be a single field for simple 6138 // returns, a slice of interfaces for anonymous returns and a struct for named 6139 // returns. 6140 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 6141 return _PauserRoleRenounceTarget.Contract.contract.Call(opts, result, method, params...) 6142 } 6143 6144 // Transfer initiates a plain transaction to move funds to the contract, calling 6145 // its default method if one is available. 6146 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 6147 return _PauserRoleRenounceTarget.Contract.contract.Transfer(opts) 6148 } 6149 6150 // Transact invokes the (paid) contract method with params as input values. 6151 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 6152 return _PauserRoleRenounceTarget.Contract.contract.Transact(opts, method, params...) 6153 } 6154 6155 // RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d. 6156 // 6157 // Solidity: function renouncePauser() returns() 6158 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactor) RenouncePauser(opts *bind.TransactOpts) (*types.Transaction, error) { 6159 return _PauserRoleRenounceTarget.contract.Transact(opts, "renouncePauser") 6160 } 6161 6162 // RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d. 6163 // 6164 // Solidity: function renouncePauser() returns() 6165 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetSession) RenouncePauser() (*types.Transaction, error) { 6166 return _PauserRoleRenounceTarget.Contract.RenouncePauser(&_PauserRoleRenounceTarget.TransactOpts) 6167 } 6168 6169 // RenouncePauser is a paid mutator transaction binding the contract method 0x6ef8d66d. 6170 // 6171 // Solidity: function renouncePauser() returns() 6172 func (_PauserRoleRenounceTarget *PauserRoleRenounceTargetTransactorSession) RenouncePauser() (*types.Transaction, error) { 6173 return _PauserRoleRenounceTarget.Contract.RenouncePauser(&_PauserRoleRenounceTarget.TransactOpts) 6174 } 6175 6176 // RolesABI is the input ABI used to generate the binding from. 6177 const RolesABI = "[]" 6178 6179 // RolesBin is the compiled bytecode used for deploying new contracts. 6180 var RolesBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a72315820451a2112c879141f72bbe0ec00d853511a9d98646af7e3081d90a3d70270eb1564736f6c634300050c0032" 6181 6182 // DeployRoles deploys a new Ethereum contract, binding an instance of Roles to it. 6183 func DeployRoles(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *Roles, error) { 6184 parsed, err := abi.JSON(strings.NewReader(RolesABI)) 6185 if err != nil { 6186 return common.Address{}, nil, nil, err 6187 } 6188 6189 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(RolesBin), backend) 6190 if err != nil { 6191 return common.Address{}, nil, nil, err 6192 } 6193 return address, tx, &Roles{RolesCaller: RolesCaller{contract: contract}, RolesTransactor: RolesTransactor{contract: contract}, RolesFilterer: RolesFilterer{contract: contract}}, nil 6194 } 6195 6196 // Roles is an auto generated Go binding around an Ethereum contract. 6197 type Roles struct { 6198 RolesCaller // Read-only binding to the contract 6199 RolesTransactor // Write-only binding to the contract 6200 RolesFilterer // Log filterer for contract events 6201 } 6202 6203 // RolesCaller is an auto generated read-only Go binding around an Ethereum contract. 6204 type RolesCaller struct { 6205 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6206 } 6207 6208 // RolesTransactor is an auto generated write-only Go binding around an Ethereum contract. 6209 type RolesTransactor struct { 6210 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6211 } 6212 6213 // RolesFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 6214 type RolesFilterer struct { 6215 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6216 } 6217 6218 // RolesSession is an auto generated Go binding around an Ethereum contract, 6219 // with pre-set call and transact options. 6220 type RolesSession struct { 6221 Contract *Roles // Generic contract binding to set the session for 6222 CallOpts bind.CallOpts // Call options to use throughout this session 6223 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 6224 } 6225 6226 // RolesCallerSession is an auto generated read-only Go binding around an Ethereum contract, 6227 // with pre-set call options. 6228 type RolesCallerSession struct { 6229 Contract *RolesCaller // Generic contract caller binding to set the session for 6230 CallOpts bind.CallOpts // Call options to use throughout this session 6231 } 6232 6233 // RolesTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 6234 // with pre-set transact options. 6235 type RolesTransactorSession struct { 6236 Contract *RolesTransactor // Generic contract transactor binding to set the session for 6237 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 6238 } 6239 6240 // RolesRaw is an auto generated low-level Go binding around an Ethereum contract. 6241 type RolesRaw struct { 6242 Contract *Roles // Generic contract binding to access the raw methods on 6243 } 6244 6245 // RolesCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 6246 type RolesCallerRaw struct { 6247 Contract *RolesCaller // Generic read-only contract binding to access the raw methods on 6248 } 6249 6250 // RolesTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 6251 type RolesTransactorRaw struct { 6252 Contract *RolesTransactor // Generic write-only contract binding to access the raw methods on 6253 } 6254 6255 // NewRoles creates a new instance of Roles, bound to a specific deployed contract. 6256 func NewRoles(address common.Address, backend bind.ContractBackend) (*Roles, error) { 6257 contract, err := bindRoles(address, backend, backend, backend) 6258 if err != nil { 6259 return nil, err 6260 } 6261 return &Roles{RolesCaller: RolesCaller{contract: contract}, RolesTransactor: RolesTransactor{contract: contract}, RolesFilterer: RolesFilterer{contract: contract}}, nil 6262 } 6263 6264 // NewRolesCaller creates a new read-only instance of Roles, bound to a specific deployed contract. 6265 func NewRolesCaller(address common.Address, caller bind.ContractCaller) (*RolesCaller, error) { 6266 contract, err := bindRoles(address, caller, nil, nil) 6267 if err != nil { 6268 return nil, err 6269 } 6270 return &RolesCaller{contract: contract}, nil 6271 } 6272 6273 // NewRolesTransactor creates a new write-only instance of Roles, bound to a specific deployed contract. 6274 func NewRolesTransactor(address common.Address, transactor bind.ContractTransactor) (*RolesTransactor, error) { 6275 contract, err := bindRoles(address, nil, transactor, nil) 6276 if err != nil { 6277 return nil, err 6278 } 6279 return &RolesTransactor{contract: contract}, nil 6280 } 6281 6282 // NewRolesFilterer creates a new log filterer instance of Roles, bound to a specific deployed contract. 6283 func NewRolesFilterer(address common.Address, filterer bind.ContractFilterer) (*RolesFilterer, error) { 6284 contract, err := bindRoles(address, nil, nil, filterer) 6285 if err != nil { 6286 return nil, err 6287 } 6288 return &RolesFilterer{contract: contract}, nil 6289 } 6290 6291 // bindRoles binds a generic wrapper to an already deployed contract. 6292 func bindRoles(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 6293 parsed, err := abi.JSON(strings.NewReader(RolesABI)) 6294 if err != nil { 6295 return nil, err 6296 } 6297 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 6298 } 6299 6300 // Call invokes the (constant) contract method with params as input values and 6301 // sets the output to result. The result type might be a single field for simple 6302 // returns, a slice of interfaces for anonymous returns and a struct for named 6303 // returns. 6304 func (_Roles *RolesRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 6305 return _Roles.Contract.RolesCaller.contract.Call(opts, result, method, params...) 6306 } 6307 6308 // Transfer initiates a plain transaction to move funds to the contract, calling 6309 // its default method if one is available. 6310 func (_Roles *RolesRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 6311 return _Roles.Contract.RolesTransactor.contract.Transfer(opts) 6312 } 6313 6314 // Transact invokes the (paid) contract method with params as input values. 6315 func (_Roles *RolesRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 6316 return _Roles.Contract.RolesTransactor.contract.Transact(opts, method, params...) 6317 } 6318 6319 // Call invokes the (constant) contract method with params as input values and 6320 // sets the output to result. The result type might be a single field for simple 6321 // returns, a slice of interfaces for anonymous returns and a struct for named 6322 // returns. 6323 func (_Roles *RolesCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 6324 return _Roles.Contract.contract.Call(opts, result, method, params...) 6325 } 6326 6327 // Transfer initiates a plain transaction to move funds to the contract, calling 6328 // its default method if one is available. 6329 func (_Roles *RolesTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 6330 return _Roles.Contract.contract.Transfer(opts) 6331 } 6332 6333 // Transact invokes the (paid) contract method with params as input values. 6334 func (_Roles *RolesTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 6335 return _Roles.Contract.contract.Transact(opts, method, params...) 6336 } 6337 6338 // SafeMathABI is the input ABI used to generate the binding from. 6339 const SafeMathABI = "[]" 6340 6341 // SafeMathBin is the compiled bytecode used for deploying new contracts. 6342 var SafeMathBin = "0x60556023600b82828239805160001a607314601657fe5b30600052607381538281f3fe73000000000000000000000000000000000000000030146080604052600080fdfea265627a7a7231582045f810ccb41cd151344ccf006ddfbe7c3c58a867d26e345c6576ae09178171dc64736f6c634300050c0032" 6343 6344 // DeploySafeMath deploys a new Ethereum contract, binding an instance of SafeMath to it. 6345 func DeploySafeMath(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SafeMath, error) { 6346 parsed, err := abi.JSON(strings.NewReader(SafeMathABI)) 6347 if err != nil { 6348 return common.Address{}, nil, nil, err 6349 } 6350 6351 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SafeMathBin), backend) 6352 if err != nil { 6353 return common.Address{}, nil, nil, err 6354 } 6355 return address, tx, &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil 6356 } 6357 6358 // SafeMath is an auto generated Go binding around an Ethereum contract. 6359 type SafeMath struct { 6360 SafeMathCaller // Read-only binding to the contract 6361 SafeMathTransactor // Write-only binding to the contract 6362 SafeMathFilterer // Log filterer for contract events 6363 } 6364 6365 // SafeMathCaller is an auto generated read-only Go binding around an Ethereum contract. 6366 type SafeMathCaller struct { 6367 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6368 } 6369 6370 // SafeMathTransactor is an auto generated write-only Go binding around an Ethereum contract. 6371 type SafeMathTransactor struct { 6372 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6373 } 6374 6375 // SafeMathFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 6376 type SafeMathFilterer struct { 6377 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6378 } 6379 6380 // SafeMathSession is an auto generated Go binding around an Ethereum contract, 6381 // with pre-set call and transact options. 6382 type SafeMathSession struct { 6383 Contract *SafeMath // Generic contract binding to set the session for 6384 CallOpts bind.CallOpts // Call options to use throughout this session 6385 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 6386 } 6387 6388 // SafeMathCallerSession is an auto generated read-only Go binding around an Ethereum contract, 6389 // with pre-set call options. 6390 type SafeMathCallerSession struct { 6391 Contract *SafeMathCaller // Generic contract caller binding to set the session for 6392 CallOpts bind.CallOpts // Call options to use throughout this session 6393 } 6394 6395 // SafeMathTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 6396 // with pre-set transact options. 6397 type SafeMathTransactorSession struct { 6398 Contract *SafeMathTransactor // Generic contract transactor binding to set the session for 6399 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 6400 } 6401 6402 // SafeMathRaw is an auto generated low-level Go binding around an Ethereum contract. 6403 type SafeMathRaw struct { 6404 Contract *SafeMath // Generic contract binding to access the raw methods on 6405 } 6406 6407 // SafeMathCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 6408 type SafeMathCallerRaw struct { 6409 Contract *SafeMathCaller // Generic read-only contract binding to access the raw methods on 6410 } 6411 6412 // SafeMathTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 6413 type SafeMathTransactorRaw struct { 6414 Contract *SafeMathTransactor // Generic write-only contract binding to access the raw methods on 6415 } 6416 6417 // NewSafeMath creates a new instance of SafeMath, bound to a specific deployed contract. 6418 func NewSafeMath(address common.Address, backend bind.ContractBackend) (*SafeMath, error) { 6419 contract, err := bindSafeMath(address, backend, backend, backend) 6420 if err != nil { 6421 return nil, err 6422 } 6423 return &SafeMath{SafeMathCaller: SafeMathCaller{contract: contract}, SafeMathTransactor: SafeMathTransactor{contract: contract}, SafeMathFilterer: SafeMathFilterer{contract: contract}}, nil 6424 } 6425 6426 // NewSafeMathCaller creates a new read-only instance of SafeMath, bound to a specific deployed contract. 6427 func NewSafeMathCaller(address common.Address, caller bind.ContractCaller) (*SafeMathCaller, error) { 6428 contract, err := bindSafeMath(address, caller, nil, nil) 6429 if err != nil { 6430 return nil, err 6431 } 6432 return &SafeMathCaller{contract: contract}, nil 6433 } 6434 6435 // NewSafeMathTransactor creates a new write-only instance of SafeMath, bound to a specific deployed contract. 6436 func NewSafeMathTransactor(address common.Address, transactor bind.ContractTransactor) (*SafeMathTransactor, error) { 6437 contract, err := bindSafeMath(address, nil, transactor, nil) 6438 if err != nil { 6439 return nil, err 6440 } 6441 return &SafeMathTransactor{contract: contract}, nil 6442 } 6443 6444 // NewSafeMathFilterer creates a new log filterer instance of SafeMath, bound to a specific deployed contract. 6445 func NewSafeMathFilterer(address common.Address, filterer bind.ContractFilterer) (*SafeMathFilterer, error) { 6446 contract, err := bindSafeMath(address, nil, nil, filterer) 6447 if err != nil { 6448 return nil, err 6449 } 6450 return &SafeMathFilterer{contract: contract}, nil 6451 } 6452 6453 // bindSafeMath binds a generic wrapper to an already deployed contract. 6454 func bindSafeMath(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 6455 parsed, err := abi.JSON(strings.NewReader(SafeMathABI)) 6456 if err != nil { 6457 return nil, err 6458 } 6459 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 6460 } 6461 6462 // Call invokes the (constant) contract method with params as input values and 6463 // sets the output to result. The result type might be a single field for simple 6464 // returns, a slice of interfaces for anonymous returns and a struct for named 6465 // returns. 6466 func (_SafeMath *SafeMathRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 6467 return _SafeMath.Contract.SafeMathCaller.contract.Call(opts, result, method, params...) 6468 } 6469 6470 // Transfer initiates a plain transaction to move funds to the contract, calling 6471 // its default method if one is available. 6472 func (_SafeMath *SafeMathRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 6473 return _SafeMath.Contract.SafeMathTransactor.contract.Transfer(opts) 6474 } 6475 6476 // Transact invokes the (paid) contract method with params as input values. 6477 func (_SafeMath *SafeMathRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 6478 return _SafeMath.Contract.SafeMathTransactor.contract.Transact(opts, method, params...) 6479 } 6480 6481 // Call invokes the (constant) contract method with params as input values and 6482 // sets the output to result. The result type might be a single field for simple 6483 // returns, a slice of interfaces for anonymous returns and a struct for named 6484 // returns. 6485 func (_SafeMath *SafeMathCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 6486 return _SafeMath.Contract.contract.Call(opts, result, method, params...) 6487 } 6488 6489 // Transfer initiates a plain transaction to move funds to the contract, calling 6490 // its default method if one is available. 6491 func (_SafeMath *SafeMathTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 6492 return _SafeMath.Contract.contract.Transfer(opts) 6493 } 6494 6495 // Transact invokes the (paid) contract method with params as input values. 6496 func (_SafeMath *SafeMathTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 6497 return _SafeMath.Contract.contract.Transact(opts, method, params...) 6498 } 6499 6500 // SeigManagerIABI is the input ABI used to generate the binding from. 6501 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\"}]" 6502 6503 // SeigManagerIFuncSigs maps the 4-byte function signature to its string representation. 6504 var SeigManagerIFuncSigs = map[string]string{ 6505 "8bf91dc4": "DEFAULT_FACTOR()", 6506 "48c8577e": "additionalTotBurnAmount(address,address,uint256)", 6507 "4c063c19": "coinages(address)", 6508 "7b056c1b": "commissionRates(address)", 6509 "833a774f": "deployCoinage(address)", 6510 "6c7ac9d8": "depositManager()", 6511 "c59f1046": "lastCommitBlock(address)", 6512 "f35c89e8": "lastSeigBlock()", 6513 "359c4d59": "onCommit()", 6514 "412c6d50": "onDeposit(address,address,uint256)", 6515 "4a393149": "onTransfer(address,address,uint256)", 6516 "f850ffaa": "onWithdraw(address,address,uint256)", 6517 "32053c99": "pausedBlock()", 6518 "3e832e1d": "powerton()", 6519 "7b103999": "registry()", 6520 "5f40a349": "seigPerBlock()", 6521 "4224ed66": "setCommissionRate(address,uint256,bool)", 6522 "ce4cb876": "stakeOf(address,address)", 6523 "cc48b947": "ton()", 6524 "a16d6aa7": "tot()", 6525 "fa9789c8": "uncomittedStakeOf(address,address)", 6526 "1cc47890": "unpausedBlock()", 6527 "8d62d949": "wton()", 6528 } 6529 6530 // SeigManagerI is an auto generated Go binding around an Ethereum contract. 6531 type SeigManagerI struct { 6532 SeigManagerICaller // Read-only binding to the contract 6533 SeigManagerITransactor // Write-only binding to the contract 6534 SeigManagerIFilterer // Log filterer for contract events 6535 } 6536 6537 // SeigManagerICaller is an auto generated read-only Go binding around an Ethereum contract. 6538 type SeigManagerICaller struct { 6539 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6540 } 6541 6542 // SeigManagerITransactor is an auto generated write-only Go binding around an Ethereum contract. 6543 type SeigManagerITransactor struct { 6544 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6545 } 6546 6547 // SeigManagerIFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 6548 type SeigManagerIFilterer struct { 6549 contract *bind.BoundContract // Generic contract wrapper for the low level calls 6550 } 6551 6552 // SeigManagerISession is an auto generated Go binding around an Ethereum contract, 6553 // with pre-set call and transact options. 6554 type SeigManagerISession struct { 6555 Contract *SeigManagerI // Generic contract binding to set the session for 6556 CallOpts bind.CallOpts // Call options to use throughout this session 6557 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 6558 } 6559 6560 // SeigManagerICallerSession is an auto generated read-only Go binding around an Ethereum contract, 6561 // with pre-set call options. 6562 type SeigManagerICallerSession struct { 6563 Contract *SeigManagerICaller // Generic contract caller binding to set the session for 6564 CallOpts bind.CallOpts // Call options to use throughout this session 6565 } 6566 6567 // SeigManagerITransactorSession is an auto generated write-only Go binding around an Ethereum contract, 6568 // with pre-set transact options. 6569 type SeigManagerITransactorSession struct { 6570 Contract *SeigManagerITransactor // Generic contract transactor binding to set the session for 6571 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 6572 } 6573 6574 // SeigManagerIRaw is an auto generated low-level Go binding around an Ethereum contract. 6575 type SeigManagerIRaw struct { 6576 Contract *SeigManagerI // Generic contract binding to access the raw methods on 6577 } 6578 6579 // SeigManagerICallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 6580 type SeigManagerICallerRaw struct { 6581 Contract *SeigManagerICaller // Generic read-only contract binding to access the raw methods on 6582 } 6583 6584 // SeigManagerITransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 6585 type SeigManagerITransactorRaw struct { 6586 Contract *SeigManagerITransactor // Generic write-only contract binding to access the raw methods on 6587 } 6588 6589 // NewSeigManagerI creates a new instance of SeigManagerI, bound to a specific deployed contract. 6590 func NewSeigManagerI(address common.Address, backend bind.ContractBackend) (*SeigManagerI, error) { 6591 contract, err := bindSeigManagerI(address, backend, backend, backend) 6592 if err != nil { 6593 return nil, err 6594 } 6595 return &SeigManagerI{SeigManagerICaller: SeigManagerICaller{contract: contract}, SeigManagerITransactor: SeigManagerITransactor{contract: contract}, SeigManagerIFilterer: SeigManagerIFilterer{contract: contract}}, nil 6596 } 6597 6598 // NewSeigManagerICaller creates a new read-only instance of SeigManagerI, bound to a specific deployed contract. 6599 func NewSeigManagerICaller(address common.Address, caller bind.ContractCaller) (*SeigManagerICaller, error) { 6600 contract, err := bindSeigManagerI(address, caller, nil, nil) 6601 if err != nil { 6602 return nil, err 6603 } 6604 return &SeigManagerICaller{contract: contract}, nil 6605 } 6606 6607 // NewSeigManagerITransactor creates a new write-only instance of SeigManagerI, bound to a specific deployed contract. 6608 func NewSeigManagerITransactor(address common.Address, transactor bind.ContractTransactor) (*SeigManagerITransactor, error) { 6609 contract, err := bindSeigManagerI(address, nil, transactor, nil) 6610 if err != nil { 6611 return nil, err 6612 } 6613 return &SeigManagerITransactor{contract: contract}, nil 6614 } 6615 6616 // NewSeigManagerIFilterer creates a new log filterer instance of SeigManagerI, bound to a specific deployed contract. 6617 func NewSeigManagerIFilterer(address common.Address, filterer bind.ContractFilterer) (*SeigManagerIFilterer, error) { 6618 contract, err := bindSeigManagerI(address, nil, nil, filterer) 6619 if err != nil { 6620 return nil, err 6621 } 6622 return &SeigManagerIFilterer{contract: contract}, nil 6623 } 6624 6625 // bindSeigManagerI binds a generic wrapper to an already deployed contract. 6626 func bindSeigManagerI(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 6627 parsed, err := abi.JSON(strings.NewReader(SeigManagerIABI)) 6628 if err != nil { 6629 return nil, err 6630 } 6631 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 6632 } 6633 6634 // Call invokes the (constant) contract method with params as input values and 6635 // sets the output to result. The result type might be a single field for simple 6636 // returns, a slice of interfaces for anonymous returns and a struct for named 6637 // returns. 6638 func (_SeigManagerI *SeigManagerIRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 6639 return _SeigManagerI.Contract.SeigManagerICaller.contract.Call(opts, result, method, params...) 6640 } 6641 6642 // Transfer initiates a plain transaction to move funds to the contract, calling 6643 // its default method if one is available. 6644 func (_SeigManagerI *SeigManagerIRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 6645 return _SeigManagerI.Contract.SeigManagerITransactor.contract.Transfer(opts) 6646 } 6647 6648 // Transact invokes the (paid) contract method with params as input values. 6649 func (_SeigManagerI *SeigManagerIRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 6650 return _SeigManagerI.Contract.SeigManagerITransactor.contract.Transact(opts, method, params...) 6651 } 6652 6653 // Call invokes the (constant) contract method with params as input values and 6654 // sets the output to result. The result type might be a single field for simple 6655 // returns, a slice of interfaces for anonymous returns and a struct for named 6656 // returns. 6657 func (_SeigManagerI *SeigManagerICallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 6658 return _SeigManagerI.Contract.contract.Call(opts, result, method, params...) 6659 } 6660 6661 // Transfer initiates a plain transaction to move funds to the contract, calling 6662 // its default method if one is available. 6663 func (_SeigManagerI *SeigManagerITransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 6664 return _SeigManagerI.Contract.contract.Transfer(opts) 6665 } 6666 6667 // Transact invokes the (paid) contract method with params as input values. 6668 func (_SeigManagerI *SeigManagerITransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 6669 return _SeigManagerI.Contract.contract.Transact(opts, method, params...) 6670 } 6671 6672 // DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4. 6673 // 6674 // Solidity: function DEFAULT_FACTOR() constant returns(uint256) 6675 func (_SeigManagerI *SeigManagerICaller) DEFAULTFACTOR(opts *bind.CallOpts) (*big.Int, error) { 6676 var ( 6677 ret0 = new(*big.Int) 6678 ) 6679 out := ret0 6680 err := _SeigManagerI.contract.Call(opts, out, "DEFAULT_FACTOR") 6681 return *ret0, err 6682 } 6683 6684 // DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4. 6685 // 6686 // Solidity: function DEFAULT_FACTOR() constant returns(uint256) 6687 func (_SeigManagerI *SeigManagerISession) DEFAULTFACTOR() (*big.Int, error) { 6688 return _SeigManagerI.Contract.DEFAULTFACTOR(&_SeigManagerI.CallOpts) 6689 } 6690 6691 // DEFAULTFACTOR is a free data retrieval call binding the contract method 0x8bf91dc4. 6692 // 6693 // Solidity: function DEFAULT_FACTOR() constant returns(uint256) 6694 func (_SeigManagerI *SeigManagerICallerSession) DEFAULTFACTOR() (*big.Int, error) { 6695 return _SeigManagerI.Contract.DEFAULTFACTOR(&_SeigManagerI.CallOpts) 6696 } 6697 6698 // AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e. 6699 // 6700 // Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount) 6701 func (_SeigManagerI *SeigManagerICaller) AdditionalTotBurnAmount(opts *bind.CallOpts, rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) { 6702 var ( 6703 ret0 = new(*big.Int) 6704 ) 6705 out := ret0 6706 err := _SeigManagerI.contract.Call(opts, out, "additionalTotBurnAmount", rootchain, account, amount) 6707 return *ret0, err 6708 } 6709 6710 // AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e. 6711 // 6712 // Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount) 6713 func (_SeigManagerI *SeigManagerISession) AdditionalTotBurnAmount(rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) { 6714 return _SeigManagerI.Contract.AdditionalTotBurnAmount(&_SeigManagerI.CallOpts, rootchain, account, amount) 6715 } 6716 6717 // AdditionalTotBurnAmount is a free data retrieval call binding the contract method 0x48c8577e. 6718 // 6719 // Solidity: function additionalTotBurnAmount(address rootchain, address account, uint256 amount) constant returns(uint256 totAmount) 6720 func (_SeigManagerI *SeigManagerICallerSession) AdditionalTotBurnAmount(rootchain common.Address, account common.Address, amount *big.Int) (*big.Int, error) { 6721 return _SeigManagerI.Contract.AdditionalTotBurnAmount(&_SeigManagerI.CallOpts, rootchain, account, amount) 6722 } 6723 6724 // Coinages is a free data retrieval call binding the contract method 0x4c063c19. 6725 // 6726 // Solidity: function coinages(address rootchain) constant returns(address) 6727 func (_SeigManagerI *SeigManagerICaller) Coinages(opts *bind.CallOpts, rootchain common.Address) (common.Address, error) { 6728 var ( 6729 ret0 = new(common.Address) 6730 ) 6731 out := ret0 6732 err := _SeigManagerI.contract.Call(opts, out, "coinages", rootchain) 6733 return *ret0, err 6734 } 6735 6736 // Coinages is a free data retrieval call binding the contract method 0x4c063c19. 6737 // 6738 // Solidity: function coinages(address rootchain) constant returns(address) 6739 func (_SeigManagerI *SeigManagerISession) Coinages(rootchain common.Address) (common.Address, error) { 6740 return _SeigManagerI.Contract.Coinages(&_SeigManagerI.CallOpts, rootchain) 6741 } 6742 6743 // Coinages is a free data retrieval call binding the contract method 0x4c063c19. 6744 // 6745 // Solidity: function coinages(address rootchain) constant returns(address) 6746 func (_SeigManagerI *SeigManagerICallerSession) Coinages(rootchain common.Address) (common.Address, error) { 6747 return _SeigManagerI.Contract.Coinages(&_SeigManagerI.CallOpts, rootchain) 6748 } 6749 6750 // CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b. 6751 // 6752 // Solidity: function commissionRates(address rootchain) constant returns(uint256) 6753 func (_SeigManagerI *SeigManagerICaller) CommissionRates(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) { 6754 var ( 6755 ret0 = new(*big.Int) 6756 ) 6757 out := ret0 6758 err := _SeigManagerI.contract.Call(opts, out, "commissionRates", rootchain) 6759 return *ret0, err 6760 } 6761 6762 // CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b. 6763 // 6764 // Solidity: function commissionRates(address rootchain) constant returns(uint256) 6765 func (_SeigManagerI *SeigManagerISession) CommissionRates(rootchain common.Address) (*big.Int, error) { 6766 return _SeigManagerI.Contract.CommissionRates(&_SeigManagerI.CallOpts, rootchain) 6767 } 6768 6769 // CommissionRates is a free data retrieval call binding the contract method 0x7b056c1b. 6770 // 6771 // Solidity: function commissionRates(address rootchain) constant returns(uint256) 6772 func (_SeigManagerI *SeigManagerICallerSession) CommissionRates(rootchain common.Address) (*big.Int, error) { 6773 return _SeigManagerI.Contract.CommissionRates(&_SeigManagerI.CallOpts, rootchain) 6774 } 6775 6776 // DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8. 6777 // 6778 // Solidity: function depositManager() constant returns(address) 6779 func (_SeigManagerI *SeigManagerICaller) DepositManager(opts *bind.CallOpts) (common.Address, error) { 6780 var ( 6781 ret0 = new(common.Address) 6782 ) 6783 out := ret0 6784 err := _SeigManagerI.contract.Call(opts, out, "depositManager") 6785 return *ret0, err 6786 } 6787 6788 // DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8. 6789 // 6790 // Solidity: function depositManager() constant returns(address) 6791 func (_SeigManagerI *SeigManagerISession) DepositManager() (common.Address, error) { 6792 return _SeigManagerI.Contract.DepositManager(&_SeigManagerI.CallOpts) 6793 } 6794 6795 // DepositManager is a free data retrieval call binding the contract method 0x6c7ac9d8. 6796 // 6797 // Solidity: function depositManager() constant returns(address) 6798 func (_SeigManagerI *SeigManagerICallerSession) DepositManager() (common.Address, error) { 6799 return _SeigManagerI.Contract.DepositManager(&_SeigManagerI.CallOpts) 6800 } 6801 6802 // LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046. 6803 // 6804 // Solidity: function lastCommitBlock(address rootchain) constant returns(uint256) 6805 func (_SeigManagerI *SeigManagerICaller) LastCommitBlock(opts *bind.CallOpts, rootchain common.Address) (*big.Int, error) { 6806 var ( 6807 ret0 = new(*big.Int) 6808 ) 6809 out := ret0 6810 err := _SeigManagerI.contract.Call(opts, out, "lastCommitBlock", rootchain) 6811 return *ret0, err 6812 } 6813 6814 // LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046. 6815 // 6816 // Solidity: function lastCommitBlock(address rootchain) constant returns(uint256) 6817 func (_SeigManagerI *SeigManagerISession) LastCommitBlock(rootchain common.Address) (*big.Int, error) { 6818 return _SeigManagerI.Contract.LastCommitBlock(&_SeigManagerI.CallOpts, rootchain) 6819 } 6820 6821 // LastCommitBlock is a free data retrieval call binding the contract method 0xc59f1046. 6822 // 6823 // Solidity: function lastCommitBlock(address rootchain) constant returns(uint256) 6824 func (_SeigManagerI *SeigManagerICallerSession) LastCommitBlock(rootchain common.Address) (*big.Int, error) { 6825 return _SeigManagerI.Contract.LastCommitBlock(&_SeigManagerI.CallOpts, rootchain) 6826 } 6827 6828 // LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8. 6829 // 6830 // Solidity: function lastSeigBlock() constant returns(uint256) 6831 func (_SeigManagerI *SeigManagerICaller) LastSeigBlock(opts *bind.CallOpts) (*big.Int, error) { 6832 var ( 6833 ret0 = new(*big.Int) 6834 ) 6835 out := ret0 6836 err := _SeigManagerI.contract.Call(opts, out, "lastSeigBlock") 6837 return *ret0, err 6838 } 6839 6840 // LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8. 6841 // 6842 // Solidity: function lastSeigBlock() constant returns(uint256) 6843 func (_SeigManagerI *SeigManagerISession) LastSeigBlock() (*big.Int, error) { 6844 return _SeigManagerI.Contract.LastSeigBlock(&_SeigManagerI.CallOpts) 6845 } 6846 6847 // LastSeigBlock is a free data retrieval call binding the contract method 0xf35c89e8. 6848 // 6849 // Solidity: function lastSeigBlock() constant returns(uint256) 6850 func (_SeigManagerI *SeigManagerICallerSession) LastSeigBlock() (*big.Int, error) { 6851 return _SeigManagerI.Contract.LastSeigBlock(&_SeigManagerI.CallOpts) 6852 } 6853 6854 // PausedBlock is a free data retrieval call binding the contract method 0x32053c99. 6855 // 6856 // Solidity: function pausedBlock() constant returns(uint256) 6857 func (_SeigManagerI *SeigManagerICaller) PausedBlock(opts *bind.CallOpts) (*big.Int, error) { 6858 var ( 6859 ret0 = new(*big.Int) 6860 ) 6861 out := ret0 6862 err := _SeigManagerI.contract.Call(opts, out, "pausedBlock") 6863 return *ret0, err 6864 } 6865 6866 // PausedBlock is a free data retrieval call binding the contract method 0x32053c99. 6867 // 6868 // Solidity: function pausedBlock() constant returns(uint256) 6869 func (_SeigManagerI *SeigManagerISession) PausedBlock() (*big.Int, error) { 6870 return _SeigManagerI.Contract.PausedBlock(&_SeigManagerI.CallOpts) 6871 } 6872 6873 // PausedBlock is a free data retrieval call binding the contract method 0x32053c99. 6874 // 6875 // Solidity: function pausedBlock() constant returns(uint256) 6876 func (_SeigManagerI *SeigManagerICallerSession) PausedBlock() (*big.Int, error) { 6877 return _SeigManagerI.Contract.PausedBlock(&_SeigManagerI.CallOpts) 6878 } 6879 6880 // Powerton is a free data retrieval call binding the contract method 0x3e832e1d. 6881 // 6882 // Solidity: function powerton() constant returns(address) 6883 func (_SeigManagerI *SeigManagerICaller) Powerton(opts *bind.CallOpts) (common.Address, error) { 6884 var ( 6885 ret0 = new(common.Address) 6886 ) 6887 out := ret0 6888 err := _SeigManagerI.contract.Call(opts, out, "powerton") 6889 return *ret0, err 6890 } 6891 6892 // Powerton is a free data retrieval call binding the contract method 0x3e832e1d. 6893 // 6894 // Solidity: function powerton() constant returns(address) 6895 func (_SeigManagerI *SeigManagerISession) Powerton() (common.Address, error) { 6896 return _SeigManagerI.Contract.Powerton(&_SeigManagerI.CallOpts) 6897 } 6898 6899 // Powerton is a free data retrieval call binding the contract method 0x3e832e1d. 6900 // 6901 // Solidity: function powerton() constant returns(address) 6902 func (_SeigManagerI *SeigManagerICallerSession) Powerton() (common.Address, error) { 6903 return _SeigManagerI.Contract.Powerton(&_SeigManagerI.CallOpts) 6904 } 6905 6906 // Registry is a free data retrieval call binding the contract method 0x7b103999. 6907 // 6908 // Solidity: function registry() constant returns(address) 6909 func (_SeigManagerI *SeigManagerICaller) Registry(opts *bind.CallOpts) (common.Address, error) { 6910 var ( 6911 ret0 = new(common.Address) 6912 ) 6913 out := ret0 6914 err := _SeigManagerI.contract.Call(opts, out, "registry") 6915 return *ret0, err 6916 } 6917 6918 // Registry is a free data retrieval call binding the contract method 0x7b103999. 6919 // 6920 // Solidity: function registry() constant returns(address) 6921 func (_SeigManagerI *SeigManagerISession) Registry() (common.Address, error) { 6922 return _SeigManagerI.Contract.Registry(&_SeigManagerI.CallOpts) 6923 } 6924 6925 // Registry is a free data retrieval call binding the contract method 0x7b103999. 6926 // 6927 // Solidity: function registry() constant returns(address) 6928 func (_SeigManagerI *SeigManagerICallerSession) Registry() (common.Address, error) { 6929 return _SeigManagerI.Contract.Registry(&_SeigManagerI.CallOpts) 6930 } 6931 6932 // SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349. 6933 // 6934 // Solidity: function seigPerBlock() constant returns(uint256) 6935 func (_SeigManagerI *SeigManagerICaller) SeigPerBlock(opts *bind.CallOpts) (*big.Int, error) { 6936 var ( 6937 ret0 = new(*big.Int) 6938 ) 6939 out := ret0 6940 err := _SeigManagerI.contract.Call(opts, out, "seigPerBlock") 6941 return *ret0, err 6942 } 6943 6944 // SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349. 6945 // 6946 // Solidity: function seigPerBlock() constant returns(uint256) 6947 func (_SeigManagerI *SeigManagerISession) SeigPerBlock() (*big.Int, error) { 6948 return _SeigManagerI.Contract.SeigPerBlock(&_SeigManagerI.CallOpts) 6949 } 6950 6951 // SeigPerBlock is a free data retrieval call binding the contract method 0x5f40a349. 6952 // 6953 // Solidity: function seigPerBlock() constant returns(uint256) 6954 func (_SeigManagerI *SeigManagerICallerSession) SeigPerBlock() (*big.Int, error) { 6955 return _SeigManagerI.Contract.SeigPerBlock(&_SeigManagerI.CallOpts) 6956 } 6957 6958 // StakeOf is a free data retrieval call binding the contract method 0xce4cb876. 6959 // 6960 // Solidity: function stakeOf(address rootchain, address account) constant returns(uint256) 6961 func (_SeigManagerI *SeigManagerICaller) StakeOf(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 6962 var ( 6963 ret0 = new(*big.Int) 6964 ) 6965 out := ret0 6966 err := _SeigManagerI.contract.Call(opts, out, "stakeOf", rootchain, account) 6967 return *ret0, err 6968 } 6969 6970 // StakeOf is a free data retrieval call binding the contract method 0xce4cb876. 6971 // 6972 // Solidity: function stakeOf(address rootchain, address account) constant returns(uint256) 6973 func (_SeigManagerI *SeigManagerISession) StakeOf(rootchain common.Address, account common.Address) (*big.Int, error) { 6974 return _SeigManagerI.Contract.StakeOf(&_SeigManagerI.CallOpts, rootchain, account) 6975 } 6976 6977 // StakeOf is a free data retrieval call binding the contract method 0xce4cb876. 6978 // 6979 // Solidity: function stakeOf(address rootchain, address account) constant returns(uint256) 6980 func (_SeigManagerI *SeigManagerICallerSession) StakeOf(rootchain common.Address, account common.Address) (*big.Int, error) { 6981 return _SeigManagerI.Contract.StakeOf(&_SeigManagerI.CallOpts, rootchain, account) 6982 } 6983 6984 // Ton is a free data retrieval call binding the contract method 0xcc48b947. 6985 // 6986 // Solidity: function ton() constant returns(address) 6987 func (_SeigManagerI *SeigManagerICaller) Ton(opts *bind.CallOpts) (common.Address, error) { 6988 var ( 6989 ret0 = new(common.Address) 6990 ) 6991 out := ret0 6992 err := _SeigManagerI.contract.Call(opts, out, "ton") 6993 return *ret0, err 6994 } 6995 6996 // Ton is a free data retrieval call binding the contract method 0xcc48b947. 6997 // 6998 // Solidity: function ton() constant returns(address) 6999 func (_SeigManagerI *SeigManagerISession) Ton() (common.Address, error) { 7000 return _SeigManagerI.Contract.Ton(&_SeigManagerI.CallOpts) 7001 } 7002 7003 // Ton is a free data retrieval call binding the contract method 0xcc48b947. 7004 // 7005 // Solidity: function ton() constant returns(address) 7006 func (_SeigManagerI *SeigManagerICallerSession) Ton() (common.Address, error) { 7007 return _SeigManagerI.Contract.Ton(&_SeigManagerI.CallOpts) 7008 } 7009 7010 // Tot is a free data retrieval call binding the contract method 0xa16d6aa7. 7011 // 7012 // Solidity: function tot() constant returns(address) 7013 func (_SeigManagerI *SeigManagerICaller) Tot(opts *bind.CallOpts) (common.Address, error) { 7014 var ( 7015 ret0 = new(common.Address) 7016 ) 7017 out := ret0 7018 err := _SeigManagerI.contract.Call(opts, out, "tot") 7019 return *ret0, err 7020 } 7021 7022 // Tot is a free data retrieval call binding the contract method 0xa16d6aa7. 7023 // 7024 // Solidity: function tot() constant returns(address) 7025 func (_SeigManagerI *SeigManagerISession) Tot() (common.Address, error) { 7026 return _SeigManagerI.Contract.Tot(&_SeigManagerI.CallOpts) 7027 } 7028 7029 // Tot is a free data retrieval call binding the contract method 0xa16d6aa7. 7030 // 7031 // Solidity: function tot() constant returns(address) 7032 func (_SeigManagerI *SeigManagerICallerSession) Tot() (common.Address, error) { 7033 return _SeigManagerI.Contract.Tot(&_SeigManagerI.CallOpts) 7034 } 7035 7036 // UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8. 7037 // 7038 // Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256) 7039 func (_SeigManagerI *SeigManagerICaller) UncomittedStakeOf(opts *bind.CallOpts, rootchain common.Address, account common.Address) (*big.Int, error) { 7040 var ( 7041 ret0 = new(*big.Int) 7042 ) 7043 out := ret0 7044 err := _SeigManagerI.contract.Call(opts, out, "uncomittedStakeOf", rootchain, account) 7045 return *ret0, err 7046 } 7047 7048 // UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8. 7049 // 7050 // Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256) 7051 func (_SeigManagerI *SeigManagerISession) UncomittedStakeOf(rootchain common.Address, account common.Address) (*big.Int, error) { 7052 return _SeigManagerI.Contract.UncomittedStakeOf(&_SeigManagerI.CallOpts, rootchain, account) 7053 } 7054 7055 // UncomittedStakeOf is a free data retrieval call binding the contract method 0xfa9789c8. 7056 // 7057 // Solidity: function uncomittedStakeOf(address rootchain, address account) constant returns(uint256) 7058 func (_SeigManagerI *SeigManagerICallerSession) UncomittedStakeOf(rootchain common.Address, account common.Address) (*big.Int, error) { 7059 return _SeigManagerI.Contract.UncomittedStakeOf(&_SeigManagerI.CallOpts, rootchain, account) 7060 } 7061 7062 // UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890. 7063 // 7064 // Solidity: function unpausedBlock() constant returns(uint256) 7065 func (_SeigManagerI *SeigManagerICaller) UnpausedBlock(opts *bind.CallOpts) (*big.Int, error) { 7066 var ( 7067 ret0 = new(*big.Int) 7068 ) 7069 out := ret0 7070 err := _SeigManagerI.contract.Call(opts, out, "unpausedBlock") 7071 return *ret0, err 7072 } 7073 7074 // UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890. 7075 // 7076 // Solidity: function unpausedBlock() constant returns(uint256) 7077 func (_SeigManagerI *SeigManagerISession) UnpausedBlock() (*big.Int, error) { 7078 return _SeigManagerI.Contract.UnpausedBlock(&_SeigManagerI.CallOpts) 7079 } 7080 7081 // UnpausedBlock is a free data retrieval call binding the contract method 0x1cc47890. 7082 // 7083 // Solidity: function unpausedBlock() constant returns(uint256) 7084 func (_SeigManagerI *SeigManagerICallerSession) UnpausedBlock() (*big.Int, error) { 7085 return _SeigManagerI.Contract.UnpausedBlock(&_SeigManagerI.CallOpts) 7086 } 7087 7088 // Wton is a free data retrieval call binding the contract method 0x8d62d949. 7089 // 7090 // Solidity: function wton() constant returns(address) 7091 func (_SeigManagerI *SeigManagerICaller) Wton(opts *bind.CallOpts) (common.Address, error) { 7092 var ( 7093 ret0 = new(common.Address) 7094 ) 7095 out := ret0 7096 err := _SeigManagerI.contract.Call(opts, out, "wton") 7097 return *ret0, err 7098 } 7099 7100 // Wton is a free data retrieval call binding the contract method 0x8d62d949. 7101 // 7102 // Solidity: function wton() constant returns(address) 7103 func (_SeigManagerI *SeigManagerISession) Wton() (common.Address, error) { 7104 return _SeigManagerI.Contract.Wton(&_SeigManagerI.CallOpts) 7105 } 7106 7107 // Wton is a free data retrieval call binding the contract method 0x8d62d949. 7108 // 7109 // Solidity: function wton() constant returns(address) 7110 func (_SeigManagerI *SeigManagerICallerSession) Wton() (common.Address, error) { 7111 return _SeigManagerI.Contract.Wton(&_SeigManagerI.CallOpts) 7112 } 7113 7114 // DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f. 7115 // 7116 // Solidity: function deployCoinage(address rootchain) returns(bool) 7117 func (_SeigManagerI *SeigManagerITransactor) DeployCoinage(opts *bind.TransactOpts, rootchain common.Address) (*types.Transaction, error) { 7118 return _SeigManagerI.contract.Transact(opts, "deployCoinage", rootchain) 7119 } 7120 7121 // DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f. 7122 // 7123 // Solidity: function deployCoinage(address rootchain) returns(bool) 7124 func (_SeigManagerI *SeigManagerISession) DeployCoinage(rootchain common.Address) (*types.Transaction, error) { 7125 return _SeigManagerI.Contract.DeployCoinage(&_SeigManagerI.TransactOpts, rootchain) 7126 } 7127 7128 // DeployCoinage is a paid mutator transaction binding the contract method 0x833a774f. 7129 // 7130 // Solidity: function deployCoinage(address rootchain) returns(bool) 7131 func (_SeigManagerI *SeigManagerITransactorSession) DeployCoinage(rootchain common.Address) (*types.Transaction, error) { 7132 return _SeigManagerI.Contract.DeployCoinage(&_SeigManagerI.TransactOpts, rootchain) 7133 } 7134 7135 // OnCommit is a paid mutator transaction binding the contract method 0x359c4d59. 7136 // 7137 // Solidity: function onCommit() returns(bool) 7138 func (_SeigManagerI *SeigManagerITransactor) OnCommit(opts *bind.TransactOpts) (*types.Transaction, error) { 7139 return _SeigManagerI.contract.Transact(opts, "onCommit") 7140 } 7141 7142 // OnCommit is a paid mutator transaction binding the contract method 0x359c4d59. 7143 // 7144 // Solidity: function onCommit() returns(bool) 7145 func (_SeigManagerI *SeigManagerISession) OnCommit() (*types.Transaction, error) { 7146 return _SeigManagerI.Contract.OnCommit(&_SeigManagerI.TransactOpts) 7147 } 7148 7149 // OnCommit is a paid mutator transaction binding the contract method 0x359c4d59. 7150 // 7151 // Solidity: function onCommit() returns(bool) 7152 func (_SeigManagerI *SeigManagerITransactorSession) OnCommit() (*types.Transaction, error) { 7153 return _SeigManagerI.Contract.OnCommit(&_SeigManagerI.TransactOpts) 7154 } 7155 7156 // OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50. 7157 // 7158 // Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool) 7159 func (_SeigManagerI *SeigManagerITransactor) OnDeposit(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) { 7160 return _SeigManagerI.contract.Transact(opts, "onDeposit", rootchain, account, amount) 7161 } 7162 7163 // OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50. 7164 // 7165 // Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool) 7166 func (_SeigManagerI *SeigManagerISession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) { 7167 return _SeigManagerI.Contract.OnDeposit(&_SeigManagerI.TransactOpts, rootchain, account, amount) 7168 } 7169 7170 // OnDeposit is a paid mutator transaction binding the contract method 0x412c6d50. 7171 // 7172 // Solidity: function onDeposit(address rootchain, address account, uint256 amount) returns(bool) 7173 func (_SeigManagerI *SeigManagerITransactorSession) OnDeposit(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) { 7174 return _SeigManagerI.Contract.OnDeposit(&_SeigManagerI.TransactOpts, rootchain, account, amount) 7175 } 7176 7177 // OnTransfer is a paid mutator transaction binding the contract method 0x4a393149. 7178 // 7179 // Solidity: function onTransfer(address sender, address recipient, uint256 amount) returns(bool) 7180 func (_SeigManagerI *SeigManagerITransactor) OnTransfer(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7181 return _SeigManagerI.contract.Transact(opts, "onTransfer", sender, recipient, amount) 7182 } 7183 7184 // OnTransfer is a paid mutator transaction binding the contract method 0x4a393149. 7185 // 7186 // Solidity: function onTransfer(address sender, address recipient, uint256 amount) returns(bool) 7187 func (_SeigManagerI *SeigManagerISession) OnTransfer(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7188 return _SeigManagerI.Contract.OnTransfer(&_SeigManagerI.TransactOpts, sender, recipient, amount) 7189 } 7190 7191 // OnTransfer is a paid mutator transaction binding the contract method 0x4a393149. 7192 // 7193 // Solidity: function onTransfer(address sender, address recipient, uint256 amount) returns(bool) 7194 func (_SeigManagerI *SeigManagerITransactorSession) OnTransfer(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7195 return _SeigManagerI.Contract.OnTransfer(&_SeigManagerI.TransactOpts, sender, recipient, amount) 7196 } 7197 7198 // OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa. 7199 // 7200 // Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool) 7201 func (_SeigManagerI *SeigManagerITransactor) OnWithdraw(opts *bind.TransactOpts, rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) { 7202 return _SeigManagerI.contract.Transact(opts, "onWithdraw", rootchain, account, amount) 7203 } 7204 7205 // OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa. 7206 // 7207 // Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool) 7208 func (_SeigManagerI *SeigManagerISession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) { 7209 return _SeigManagerI.Contract.OnWithdraw(&_SeigManagerI.TransactOpts, rootchain, account, amount) 7210 } 7211 7212 // OnWithdraw is a paid mutator transaction binding the contract method 0xf850ffaa. 7213 // 7214 // Solidity: function onWithdraw(address rootchain, address account, uint256 amount) returns(bool) 7215 func (_SeigManagerI *SeigManagerITransactorSession) OnWithdraw(rootchain common.Address, account common.Address, amount *big.Int) (*types.Transaction, error) { 7216 return _SeigManagerI.Contract.OnWithdraw(&_SeigManagerI.TransactOpts, rootchain, account, amount) 7217 } 7218 7219 // SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66. 7220 // 7221 // Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool) 7222 func (_SeigManagerI *SeigManagerITransactor) SetCommissionRate(opts *bind.TransactOpts, rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) { 7223 return _SeigManagerI.contract.Transact(opts, "setCommissionRate", rootchain, commission, isCommissionRateNegative) 7224 } 7225 7226 // SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66. 7227 // 7228 // Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool) 7229 func (_SeigManagerI *SeigManagerISession) SetCommissionRate(rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) { 7230 return _SeigManagerI.Contract.SetCommissionRate(&_SeigManagerI.TransactOpts, rootchain, commission, isCommissionRateNegative) 7231 } 7232 7233 // SetCommissionRate is a paid mutator transaction binding the contract method 0x4224ed66. 7234 // 7235 // Solidity: function setCommissionRate(address rootchain, uint256 commission, bool isCommissionRateNegative) returns(bool) 7236 func (_SeigManagerI *SeigManagerITransactorSession) SetCommissionRate(rootchain common.Address, commission *big.Int, isCommissionRateNegative bool) (*types.Transaction, error) { 7237 return _SeigManagerI.Contract.SetCommissionRate(&_SeigManagerI.TransactOpts, rootchain, commission, isCommissionRateNegative) 7238 } 7239 7240 // SeigTokenABI is the input ABI used to generate the binding from. 7241 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\"}]" 7242 7243 // SeigTokenFuncSigs maps the 4-byte function signature to its string representation. 7244 var SeigTokenFuncSigs = map[string]string{ 7245 "6cd28f9a": "INTERFACE_ID_ON_APPROVE()", 7246 "dd62ed3e": "allowance(address,address)", 7247 "095ea7b3": "approve(address,uint256)", 7248 "cae9ca51": "approveAndCall(address,uint256,bytes)", 7249 "70a08231": "balanceOf(address)", 7250 "a457c2d7": "decreaseAllowance(address,uint256)", 7251 "39509351": "increaseAllowance(address,uint256)", 7252 "8f32d59b": "isOwner()", 7253 "8da5cb5b": "owner()", 7254 "5f112c68": "renounceMinter(address)", 7255 "715018a6": "renounceOwnership()", 7256 "38bf3cfa": "renounceOwnership(address)", 7257 "41eb24bb": "renouncePauser(address)", 7258 "6fb7f558": "seigManager()", 7259 "7657f20a": "setSeigManager(address)", 7260 "18160ddd": "totalSupply()", 7261 "a9059cbb": "transfer(address,uint256)", 7262 "23b872dd": "transferFrom(address,address,uint256)", 7263 "f2fde38b": "transferOwnership(address)", 7264 "6d435421": "transferOwnership(address,address)", 7265 } 7266 7267 // SeigTokenBin is the compiled bytecode used for deploying new contracts. 7268 var SeigTokenBin = "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" 7269 7270 // DeploySeigToken deploys a new Ethereum contract, binding an instance of SeigToken to it. 7271 func DeploySeigToken(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *SeigToken, error) { 7272 parsed, err := abi.JSON(strings.NewReader(SeigTokenABI)) 7273 if err != nil { 7274 return common.Address{}, nil, nil, err 7275 } 7276 7277 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(SeigTokenBin), backend) 7278 if err != nil { 7279 return common.Address{}, nil, nil, err 7280 } 7281 return address, tx, &SeigToken{SeigTokenCaller: SeigTokenCaller{contract: contract}, SeigTokenTransactor: SeigTokenTransactor{contract: contract}, SeigTokenFilterer: SeigTokenFilterer{contract: contract}}, nil 7282 } 7283 7284 // SeigToken is an auto generated Go binding around an Ethereum contract. 7285 type SeigToken struct { 7286 SeigTokenCaller // Read-only binding to the contract 7287 SeigTokenTransactor // Write-only binding to the contract 7288 SeigTokenFilterer // Log filterer for contract events 7289 } 7290 7291 // SeigTokenCaller is an auto generated read-only Go binding around an Ethereum contract. 7292 type SeigTokenCaller struct { 7293 contract *bind.BoundContract // Generic contract wrapper for the low level calls 7294 } 7295 7296 // SeigTokenTransactor is an auto generated write-only Go binding around an Ethereum contract. 7297 type SeigTokenTransactor struct { 7298 contract *bind.BoundContract // Generic contract wrapper for the low level calls 7299 } 7300 7301 // SeigTokenFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 7302 type SeigTokenFilterer struct { 7303 contract *bind.BoundContract // Generic contract wrapper for the low level calls 7304 } 7305 7306 // SeigTokenSession is an auto generated Go binding around an Ethereum contract, 7307 // with pre-set call and transact options. 7308 type SeigTokenSession struct { 7309 Contract *SeigToken // Generic contract binding to set the session for 7310 CallOpts bind.CallOpts // Call options to use throughout this session 7311 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 7312 } 7313 7314 // SeigTokenCallerSession is an auto generated read-only Go binding around an Ethereum contract, 7315 // with pre-set call options. 7316 type SeigTokenCallerSession struct { 7317 Contract *SeigTokenCaller // Generic contract caller binding to set the session for 7318 CallOpts bind.CallOpts // Call options to use throughout this session 7319 } 7320 7321 // SeigTokenTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 7322 // with pre-set transact options. 7323 type SeigTokenTransactorSession struct { 7324 Contract *SeigTokenTransactor // Generic contract transactor binding to set the session for 7325 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 7326 } 7327 7328 // SeigTokenRaw is an auto generated low-level Go binding around an Ethereum contract. 7329 type SeigTokenRaw struct { 7330 Contract *SeigToken // Generic contract binding to access the raw methods on 7331 } 7332 7333 // SeigTokenCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 7334 type SeigTokenCallerRaw struct { 7335 Contract *SeigTokenCaller // Generic read-only contract binding to access the raw methods on 7336 } 7337 7338 // SeigTokenTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 7339 type SeigTokenTransactorRaw struct { 7340 Contract *SeigTokenTransactor // Generic write-only contract binding to access the raw methods on 7341 } 7342 7343 // NewSeigToken creates a new instance of SeigToken, bound to a specific deployed contract. 7344 func NewSeigToken(address common.Address, backend bind.ContractBackend) (*SeigToken, error) { 7345 contract, err := bindSeigToken(address, backend, backend, backend) 7346 if err != nil { 7347 return nil, err 7348 } 7349 return &SeigToken{SeigTokenCaller: SeigTokenCaller{contract: contract}, SeigTokenTransactor: SeigTokenTransactor{contract: contract}, SeigTokenFilterer: SeigTokenFilterer{contract: contract}}, nil 7350 } 7351 7352 // NewSeigTokenCaller creates a new read-only instance of SeigToken, bound to a specific deployed contract. 7353 func NewSeigTokenCaller(address common.Address, caller bind.ContractCaller) (*SeigTokenCaller, error) { 7354 contract, err := bindSeigToken(address, caller, nil, nil) 7355 if err != nil { 7356 return nil, err 7357 } 7358 return &SeigTokenCaller{contract: contract}, nil 7359 } 7360 7361 // NewSeigTokenTransactor creates a new write-only instance of SeigToken, bound to a specific deployed contract. 7362 func NewSeigTokenTransactor(address common.Address, transactor bind.ContractTransactor) (*SeigTokenTransactor, error) { 7363 contract, err := bindSeigToken(address, nil, transactor, nil) 7364 if err != nil { 7365 return nil, err 7366 } 7367 return &SeigTokenTransactor{contract: contract}, nil 7368 } 7369 7370 // NewSeigTokenFilterer creates a new log filterer instance of SeigToken, bound to a specific deployed contract. 7371 func NewSeigTokenFilterer(address common.Address, filterer bind.ContractFilterer) (*SeigTokenFilterer, error) { 7372 contract, err := bindSeigToken(address, nil, nil, filterer) 7373 if err != nil { 7374 return nil, err 7375 } 7376 return &SeigTokenFilterer{contract: contract}, nil 7377 } 7378 7379 // bindSeigToken binds a generic wrapper to an already deployed contract. 7380 func bindSeigToken(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 7381 parsed, err := abi.JSON(strings.NewReader(SeigTokenABI)) 7382 if err != nil { 7383 return nil, err 7384 } 7385 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 7386 } 7387 7388 // Call invokes the (constant) contract method with params as input values and 7389 // sets the output to result. The result type might be a single field for simple 7390 // returns, a slice of interfaces for anonymous returns and a struct for named 7391 // returns. 7392 func (_SeigToken *SeigTokenRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 7393 return _SeigToken.Contract.SeigTokenCaller.contract.Call(opts, result, method, params...) 7394 } 7395 7396 // Transfer initiates a plain transaction to move funds to the contract, calling 7397 // its default method if one is available. 7398 func (_SeigToken *SeigTokenRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 7399 return _SeigToken.Contract.SeigTokenTransactor.contract.Transfer(opts) 7400 } 7401 7402 // Transact invokes the (paid) contract method with params as input values. 7403 func (_SeigToken *SeigTokenRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 7404 return _SeigToken.Contract.SeigTokenTransactor.contract.Transact(opts, method, params...) 7405 } 7406 7407 // Call invokes the (constant) contract method with params as input values and 7408 // sets the output to result. The result type might be a single field for simple 7409 // returns, a slice of interfaces for anonymous returns and a struct for named 7410 // returns. 7411 func (_SeigToken *SeigTokenCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 7412 return _SeigToken.Contract.contract.Call(opts, result, method, params...) 7413 } 7414 7415 // Transfer initiates a plain transaction to move funds to the contract, calling 7416 // its default method if one is available. 7417 func (_SeigToken *SeigTokenTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 7418 return _SeigToken.Contract.contract.Transfer(opts) 7419 } 7420 7421 // Transact invokes the (paid) contract method with params as input values. 7422 func (_SeigToken *SeigTokenTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 7423 return _SeigToken.Contract.contract.Transact(opts, method, params...) 7424 } 7425 7426 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 7427 // 7428 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 7429 func (_SeigToken *SeigTokenCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) { 7430 var ( 7431 ret0 = new([4]byte) 7432 ) 7433 out := ret0 7434 err := _SeigToken.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE") 7435 return *ret0, err 7436 } 7437 7438 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 7439 // 7440 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 7441 func (_SeigToken *SeigTokenSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 7442 return _SeigToken.Contract.INTERFACEIDONAPPROVE(&_SeigToken.CallOpts) 7443 } 7444 7445 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 7446 // 7447 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 7448 func (_SeigToken *SeigTokenCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 7449 return _SeigToken.Contract.INTERFACEIDONAPPROVE(&_SeigToken.CallOpts) 7450 } 7451 7452 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 7453 // 7454 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 7455 func (_SeigToken *SeigTokenCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 7456 var ( 7457 ret0 = new(*big.Int) 7458 ) 7459 out := ret0 7460 err := _SeigToken.contract.Call(opts, out, "allowance", owner, spender) 7461 return *ret0, err 7462 } 7463 7464 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 7465 // 7466 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 7467 func (_SeigToken *SeigTokenSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 7468 return _SeigToken.Contract.Allowance(&_SeigToken.CallOpts, owner, spender) 7469 } 7470 7471 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 7472 // 7473 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 7474 func (_SeigToken *SeigTokenCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 7475 return _SeigToken.Contract.Allowance(&_SeigToken.CallOpts, owner, spender) 7476 } 7477 7478 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 7479 // 7480 // Solidity: function balanceOf(address account) constant returns(uint256) 7481 func (_SeigToken *SeigTokenCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 7482 var ( 7483 ret0 = new(*big.Int) 7484 ) 7485 out := ret0 7486 err := _SeigToken.contract.Call(opts, out, "balanceOf", account) 7487 return *ret0, err 7488 } 7489 7490 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 7491 // 7492 // Solidity: function balanceOf(address account) constant returns(uint256) 7493 func (_SeigToken *SeigTokenSession) BalanceOf(account common.Address) (*big.Int, error) { 7494 return _SeigToken.Contract.BalanceOf(&_SeigToken.CallOpts, account) 7495 } 7496 7497 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 7498 // 7499 // Solidity: function balanceOf(address account) constant returns(uint256) 7500 func (_SeigToken *SeigTokenCallerSession) BalanceOf(account common.Address) (*big.Int, error) { 7501 return _SeigToken.Contract.BalanceOf(&_SeigToken.CallOpts, account) 7502 } 7503 7504 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 7505 // 7506 // Solidity: function isOwner() constant returns(bool) 7507 func (_SeigToken *SeigTokenCaller) IsOwner(opts *bind.CallOpts) (bool, error) { 7508 var ( 7509 ret0 = new(bool) 7510 ) 7511 out := ret0 7512 err := _SeigToken.contract.Call(opts, out, "isOwner") 7513 return *ret0, err 7514 } 7515 7516 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 7517 // 7518 // Solidity: function isOwner() constant returns(bool) 7519 func (_SeigToken *SeigTokenSession) IsOwner() (bool, error) { 7520 return _SeigToken.Contract.IsOwner(&_SeigToken.CallOpts) 7521 } 7522 7523 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 7524 // 7525 // Solidity: function isOwner() constant returns(bool) 7526 func (_SeigToken *SeigTokenCallerSession) IsOwner() (bool, error) { 7527 return _SeigToken.Contract.IsOwner(&_SeigToken.CallOpts) 7528 } 7529 7530 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 7531 // 7532 // Solidity: function owner() constant returns(address) 7533 func (_SeigToken *SeigTokenCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 7534 var ( 7535 ret0 = new(common.Address) 7536 ) 7537 out := ret0 7538 err := _SeigToken.contract.Call(opts, out, "owner") 7539 return *ret0, err 7540 } 7541 7542 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 7543 // 7544 // Solidity: function owner() constant returns(address) 7545 func (_SeigToken *SeigTokenSession) Owner() (common.Address, error) { 7546 return _SeigToken.Contract.Owner(&_SeigToken.CallOpts) 7547 } 7548 7549 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 7550 // 7551 // Solidity: function owner() constant returns(address) 7552 func (_SeigToken *SeigTokenCallerSession) Owner() (common.Address, error) { 7553 return _SeigToken.Contract.Owner(&_SeigToken.CallOpts) 7554 } 7555 7556 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 7557 // 7558 // Solidity: function seigManager() constant returns(address) 7559 func (_SeigToken *SeigTokenCaller) SeigManager(opts *bind.CallOpts) (common.Address, error) { 7560 var ( 7561 ret0 = new(common.Address) 7562 ) 7563 out := ret0 7564 err := _SeigToken.contract.Call(opts, out, "seigManager") 7565 return *ret0, err 7566 } 7567 7568 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 7569 // 7570 // Solidity: function seigManager() constant returns(address) 7571 func (_SeigToken *SeigTokenSession) SeigManager() (common.Address, error) { 7572 return _SeigToken.Contract.SeigManager(&_SeigToken.CallOpts) 7573 } 7574 7575 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 7576 // 7577 // Solidity: function seigManager() constant returns(address) 7578 func (_SeigToken *SeigTokenCallerSession) SeigManager() (common.Address, error) { 7579 return _SeigToken.Contract.SeigManager(&_SeigToken.CallOpts) 7580 } 7581 7582 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 7583 // 7584 // Solidity: function totalSupply() constant returns(uint256) 7585 func (_SeigToken *SeigTokenCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 7586 var ( 7587 ret0 = new(*big.Int) 7588 ) 7589 out := ret0 7590 err := _SeigToken.contract.Call(opts, out, "totalSupply") 7591 return *ret0, err 7592 } 7593 7594 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 7595 // 7596 // Solidity: function totalSupply() constant returns(uint256) 7597 func (_SeigToken *SeigTokenSession) TotalSupply() (*big.Int, error) { 7598 return _SeigToken.Contract.TotalSupply(&_SeigToken.CallOpts) 7599 } 7600 7601 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 7602 // 7603 // Solidity: function totalSupply() constant returns(uint256) 7604 func (_SeigToken *SeigTokenCallerSession) TotalSupply() (*big.Int, error) { 7605 return _SeigToken.Contract.TotalSupply(&_SeigToken.CallOpts) 7606 } 7607 7608 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 7609 // 7610 // Solidity: function approve(address spender, uint256 amount) returns(bool) 7611 func (_SeigToken *SeigTokenTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 7612 return _SeigToken.contract.Transact(opts, "approve", spender, amount) 7613 } 7614 7615 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 7616 // 7617 // Solidity: function approve(address spender, uint256 amount) returns(bool) 7618 func (_SeigToken *SeigTokenSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 7619 return _SeigToken.Contract.Approve(&_SeigToken.TransactOpts, spender, amount) 7620 } 7621 7622 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 7623 // 7624 // Solidity: function approve(address spender, uint256 amount) returns(bool) 7625 func (_SeigToken *SeigTokenTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 7626 return _SeigToken.Contract.Approve(&_SeigToken.TransactOpts, spender, amount) 7627 } 7628 7629 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 7630 // 7631 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 7632 func (_SeigToken *SeigTokenTransactor) ApproveAndCall(opts *bind.TransactOpts, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 7633 return _SeigToken.contract.Transact(opts, "approveAndCall", spender, amount, data) 7634 } 7635 7636 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 7637 // 7638 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 7639 func (_SeigToken *SeigTokenSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 7640 return _SeigToken.Contract.ApproveAndCall(&_SeigToken.TransactOpts, spender, amount, data) 7641 } 7642 7643 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 7644 // 7645 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 7646 func (_SeigToken *SeigTokenTransactorSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 7647 return _SeigToken.Contract.ApproveAndCall(&_SeigToken.TransactOpts, spender, amount, data) 7648 } 7649 7650 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 7651 // 7652 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 7653 func (_SeigToken *SeigTokenTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 7654 return _SeigToken.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) 7655 } 7656 7657 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 7658 // 7659 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 7660 func (_SeigToken *SeigTokenSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 7661 return _SeigToken.Contract.DecreaseAllowance(&_SeigToken.TransactOpts, spender, subtractedValue) 7662 } 7663 7664 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 7665 // 7666 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 7667 func (_SeigToken *SeigTokenTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 7668 return _SeigToken.Contract.DecreaseAllowance(&_SeigToken.TransactOpts, spender, subtractedValue) 7669 } 7670 7671 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 7672 // 7673 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 7674 func (_SeigToken *SeigTokenTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 7675 return _SeigToken.contract.Transact(opts, "increaseAllowance", spender, addedValue) 7676 } 7677 7678 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 7679 // 7680 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 7681 func (_SeigToken *SeigTokenSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 7682 return _SeigToken.Contract.IncreaseAllowance(&_SeigToken.TransactOpts, spender, addedValue) 7683 } 7684 7685 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 7686 // 7687 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 7688 func (_SeigToken *SeigTokenTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 7689 return _SeigToken.Contract.IncreaseAllowance(&_SeigToken.TransactOpts, spender, addedValue) 7690 } 7691 7692 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 7693 // 7694 // Solidity: function renounceMinter(address target) returns() 7695 func (_SeigToken *SeigTokenTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 7696 return _SeigToken.contract.Transact(opts, "renounceMinter", target) 7697 } 7698 7699 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 7700 // 7701 // Solidity: function renounceMinter(address target) returns() 7702 func (_SeigToken *SeigTokenSession) RenounceMinter(target common.Address) (*types.Transaction, error) { 7703 return _SeigToken.Contract.RenounceMinter(&_SeigToken.TransactOpts, target) 7704 } 7705 7706 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 7707 // 7708 // Solidity: function renounceMinter(address target) returns() 7709 func (_SeigToken *SeigTokenTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) { 7710 return _SeigToken.Contract.RenounceMinter(&_SeigToken.TransactOpts, target) 7711 } 7712 7713 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 7714 // 7715 // Solidity: function renounceOwnership(address target) returns() 7716 func (_SeigToken *SeigTokenTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 7717 return _SeigToken.contract.Transact(opts, "renounceOwnership", target) 7718 } 7719 7720 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 7721 // 7722 // Solidity: function renounceOwnership(address target) returns() 7723 func (_SeigToken *SeigTokenSession) RenounceOwnership(target common.Address) (*types.Transaction, error) { 7724 return _SeigToken.Contract.RenounceOwnership(&_SeigToken.TransactOpts, target) 7725 } 7726 7727 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 7728 // 7729 // Solidity: function renounceOwnership(address target) returns() 7730 func (_SeigToken *SeigTokenTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) { 7731 return _SeigToken.Contract.RenounceOwnership(&_SeigToken.TransactOpts, target) 7732 } 7733 7734 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 7735 // 7736 // Solidity: function renounceOwnership() returns() 7737 func (_SeigToken *SeigTokenTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) { 7738 return _SeigToken.contract.Transact(opts, "renounceOwnership0") 7739 } 7740 7741 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 7742 // 7743 // Solidity: function renounceOwnership() returns() 7744 func (_SeigToken *SeigTokenSession) RenounceOwnership0() (*types.Transaction, error) { 7745 return _SeigToken.Contract.RenounceOwnership0(&_SeigToken.TransactOpts) 7746 } 7747 7748 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 7749 // 7750 // Solidity: function renounceOwnership() returns() 7751 func (_SeigToken *SeigTokenTransactorSession) RenounceOwnership0() (*types.Transaction, error) { 7752 return _SeigToken.Contract.RenounceOwnership0(&_SeigToken.TransactOpts) 7753 } 7754 7755 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 7756 // 7757 // Solidity: function renouncePauser(address target) returns() 7758 func (_SeigToken *SeigTokenTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 7759 return _SeigToken.contract.Transact(opts, "renouncePauser", target) 7760 } 7761 7762 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 7763 // 7764 // Solidity: function renouncePauser(address target) returns() 7765 func (_SeigToken *SeigTokenSession) RenouncePauser(target common.Address) (*types.Transaction, error) { 7766 return _SeigToken.Contract.RenouncePauser(&_SeigToken.TransactOpts, target) 7767 } 7768 7769 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 7770 // 7771 // Solidity: function renouncePauser(address target) returns() 7772 func (_SeigToken *SeigTokenTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) { 7773 return _SeigToken.Contract.RenouncePauser(&_SeigToken.TransactOpts, target) 7774 } 7775 7776 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 7777 // 7778 // Solidity: function setSeigManager(address _seigManager) returns() 7779 func (_SeigToken *SeigTokenTransactor) SetSeigManager(opts *bind.TransactOpts, _seigManager common.Address) (*types.Transaction, error) { 7780 return _SeigToken.contract.Transact(opts, "setSeigManager", _seigManager) 7781 } 7782 7783 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 7784 // 7785 // Solidity: function setSeigManager(address _seigManager) returns() 7786 func (_SeigToken *SeigTokenSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) { 7787 return _SeigToken.Contract.SetSeigManager(&_SeigToken.TransactOpts, _seigManager) 7788 } 7789 7790 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 7791 // 7792 // Solidity: function setSeigManager(address _seigManager) returns() 7793 func (_SeigToken *SeigTokenTransactorSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) { 7794 return _SeigToken.Contract.SetSeigManager(&_SeigToken.TransactOpts, _seigManager) 7795 } 7796 7797 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 7798 // 7799 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 7800 func (_SeigToken *SeigTokenTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7801 return _SeigToken.contract.Transact(opts, "transfer", recipient, amount) 7802 } 7803 7804 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 7805 // 7806 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 7807 func (_SeigToken *SeigTokenSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7808 return _SeigToken.Contract.Transfer(&_SeigToken.TransactOpts, recipient, amount) 7809 } 7810 7811 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 7812 // 7813 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 7814 func (_SeigToken *SeigTokenTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7815 return _SeigToken.Contract.Transfer(&_SeigToken.TransactOpts, recipient, amount) 7816 } 7817 7818 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 7819 // 7820 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 7821 func (_SeigToken *SeigTokenTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7822 return _SeigToken.contract.Transact(opts, "transferFrom", sender, recipient, amount) 7823 } 7824 7825 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 7826 // 7827 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 7828 func (_SeigToken *SeigTokenSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7829 return _SeigToken.Contract.TransferFrom(&_SeigToken.TransactOpts, sender, recipient, amount) 7830 } 7831 7832 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 7833 // 7834 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 7835 func (_SeigToken *SeigTokenTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 7836 return _SeigToken.Contract.TransferFrom(&_SeigToken.TransactOpts, sender, recipient, amount) 7837 } 7838 7839 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 7840 // 7841 // Solidity: function transferOwnership(address target, address newOwner) returns() 7842 func (_SeigToken *SeigTokenTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) { 7843 return _SeigToken.contract.Transact(opts, "transferOwnership", target, newOwner) 7844 } 7845 7846 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 7847 // 7848 // Solidity: function transferOwnership(address target, address newOwner) returns() 7849 func (_SeigToken *SeigTokenSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) { 7850 return _SeigToken.Contract.TransferOwnership(&_SeigToken.TransactOpts, target, newOwner) 7851 } 7852 7853 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 7854 // 7855 // Solidity: function transferOwnership(address target, address newOwner) returns() 7856 func (_SeigToken *SeigTokenTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) { 7857 return _SeigToken.Contract.TransferOwnership(&_SeigToken.TransactOpts, target, newOwner) 7858 } 7859 7860 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 7861 // 7862 // Solidity: function transferOwnership(address newOwner) returns() 7863 func (_SeigToken *SeigTokenTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 7864 return _SeigToken.contract.Transact(opts, "transferOwnership0", newOwner) 7865 } 7866 7867 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 7868 // 7869 // Solidity: function transferOwnership(address newOwner) returns() 7870 func (_SeigToken *SeigTokenSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) { 7871 return _SeigToken.Contract.TransferOwnership0(&_SeigToken.TransactOpts, newOwner) 7872 } 7873 7874 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 7875 // 7876 // Solidity: function transferOwnership(address newOwner) returns() 7877 func (_SeigToken *SeigTokenTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) { 7878 return _SeigToken.Contract.TransferOwnership0(&_SeigToken.TransactOpts, newOwner) 7879 } 7880 7881 // 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. 7882 type SeigTokenApprovalIterator struct { 7883 Event *SeigTokenApproval // Event containing the contract specifics and raw log 7884 7885 contract *bind.BoundContract // Generic contract to use for unpacking event data 7886 event string // Event name to use for unpacking event data 7887 7888 logs chan types.Log // Log channel receiving the found contract events 7889 sub ethereum.Subscription // Subscription for errors, completion and termination 7890 done bool // Whether the subscription completed delivering logs 7891 fail error // Occurred error to stop iteration 7892 } 7893 7894 // Next advances the iterator to the subsequent event, returning whether there 7895 // are any more events found. In case of a retrieval or parsing error, false is 7896 // returned and Error() can be queried for the exact failure. 7897 func (it *SeigTokenApprovalIterator) Next() bool { 7898 // If the iterator failed, stop iterating 7899 if it.fail != nil { 7900 return false 7901 } 7902 // If the iterator completed, deliver directly whatever's available 7903 if it.done { 7904 select { 7905 case log := <-it.logs: 7906 it.Event = new(SeigTokenApproval) 7907 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 7908 it.fail = err 7909 return false 7910 } 7911 it.Event.Raw = log 7912 return true 7913 7914 default: 7915 return false 7916 } 7917 } 7918 // Iterator still in progress, wait for either a data or an error event 7919 select { 7920 case log := <-it.logs: 7921 it.Event = new(SeigTokenApproval) 7922 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 7923 it.fail = err 7924 return false 7925 } 7926 it.Event.Raw = log 7927 return true 7928 7929 case err := <-it.sub.Err(): 7930 it.done = true 7931 it.fail = err 7932 return it.Next() 7933 } 7934 } 7935 7936 // Error returns any retrieval or parsing error occurred during filtering. 7937 func (it *SeigTokenApprovalIterator) Error() error { 7938 return it.fail 7939 } 7940 7941 // Close terminates the iteration process, releasing any pending underlying 7942 // resources. 7943 func (it *SeigTokenApprovalIterator) Close() error { 7944 it.sub.Unsubscribe() 7945 return nil 7946 } 7947 7948 // SeigTokenApproval represents a Approval event raised by the SeigToken contract. 7949 type SeigTokenApproval struct { 7950 Owner common.Address 7951 Spender common.Address 7952 Value *big.Int 7953 Raw types.Log // Blockchain specific contextual infos 7954 } 7955 7956 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 7957 // 7958 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 7959 func (_SeigToken *SeigTokenFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*SeigTokenApprovalIterator, error) { 7960 7961 var ownerRule []interface{} 7962 for _, ownerItem := range owner { 7963 ownerRule = append(ownerRule, ownerItem) 7964 } 7965 var spenderRule []interface{} 7966 for _, spenderItem := range spender { 7967 spenderRule = append(spenderRule, spenderItem) 7968 } 7969 7970 logs, sub, err := _SeigToken.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 7971 if err != nil { 7972 return nil, err 7973 } 7974 return &SeigTokenApprovalIterator{contract: _SeigToken.contract, event: "Approval", logs: logs, sub: sub}, nil 7975 } 7976 7977 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 7978 // 7979 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 7980 func (_SeigToken *SeigTokenFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *SeigTokenApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 7981 7982 var ownerRule []interface{} 7983 for _, ownerItem := range owner { 7984 ownerRule = append(ownerRule, ownerItem) 7985 } 7986 var spenderRule []interface{} 7987 for _, spenderItem := range spender { 7988 spenderRule = append(spenderRule, spenderItem) 7989 } 7990 7991 logs, sub, err := _SeigToken.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 7992 if err != nil { 7993 return nil, err 7994 } 7995 return event.NewSubscription(func(quit <-chan struct{}) error { 7996 defer sub.Unsubscribe() 7997 for { 7998 select { 7999 case log := <-logs: 8000 // New log arrived, parse the event and forward to the user 8001 event := new(SeigTokenApproval) 8002 if err := _SeigToken.contract.UnpackLog(event, "Approval", log); err != nil { 8003 return err 8004 } 8005 event.Raw = log 8006 8007 select { 8008 case sink <- event: 8009 case err := <-sub.Err(): 8010 return err 8011 case <-quit: 8012 return nil 8013 } 8014 case err := <-sub.Err(): 8015 return err 8016 case <-quit: 8017 return nil 8018 } 8019 } 8020 }), nil 8021 } 8022 8023 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 8024 // 8025 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 8026 func (_SeigToken *SeigTokenFilterer) ParseApproval(log types.Log) (*SeigTokenApproval, error) { 8027 event := new(SeigTokenApproval) 8028 if err := _SeigToken.contract.UnpackLog(event, "Approval", log); err != nil { 8029 return nil, err 8030 } 8031 return event, nil 8032 } 8033 8034 // 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. 8035 type SeigTokenOwnershipTransferredIterator struct { 8036 Event *SeigTokenOwnershipTransferred // Event containing the contract specifics and raw log 8037 8038 contract *bind.BoundContract // Generic contract to use for unpacking event data 8039 event string // Event name to use for unpacking event data 8040 8041 logs chan types.Log // Log channel receiving the found contract events 8042 sub ethereum.Subscription // Subscription for errors, completion and termination 8043 done bool // Whether the subscription completed delivering logs 8044 fail error // Occurred error to stop iteration 8045 } 8046 8047 // Next advances the iterator to the subsequent event, returning whether there 8048 // are any more events found. In case of a retrieval or parsing error, false is 8049 // returned and Error() can be queried for the exact failure. 8050 func (it *SeigTokenOwnershipTransferredIterator) Next() bool { 8051 // If the iterator failed, stop iterating 8052 if it.fail != nil { 8053 return false 8054 } 8055 // If the iterator completed, deliver directly whatever's available 8056 if it.done { 8057 select { 8058 case log := <-it.logs: 8059 it.Event = new(SeigTokenOwnershipTransferred) 8060 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 8061 it.fail = err 8062 return false 8063 } 8064 it.Event.Raw = log 8065 return true 8066 8067 default: 8068 return false 8069 } 8070 } 8071 // Iterator still in progress, wait for either a data or an error event 8072 select { 8073 case log := <-it.logs: 8074 it.Event = new(SeigTokenOwnershipTransferred) 8075 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 8076 it.fail = err 8077 return false 8078 } 8079 it.Event.Raw = log 8080 return true 8081 8082 case err := <-it.sub.Err(): 8083 it.done = true 8084 it.fail = err 8085 return it.Next() 8086 } 8087 } 8088 8089 // Error returns any retrieval or parsing error occurred during filtering. 8090 func (it *SeigTokenOwnershipTransferredIterator) Error() error { 8091 return it.fail 8092 } 8093 8094 // Close terminates the iteration process, releasing any pending underlying 8095 // resources. 8096 func (it *SeigTokenOwnershipTransferredIterator) Close() error { 8097 it.sub.Unsubscribe() 8098 return nil 8099 } 8100 8101 // SeigTokenOwnershipTransferred represents a OwnershipTransferred event raised by the SeigToken contract. 8102 type SeigTokenOwnershipTransferred struct { 8103 PreviousOwner common.Address 8104 NewOwner common.Address 8105 Raw types.Log // Blockchain specific contextual infos 8106 } 8107 8108 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 8109 // 8110 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 8111 func (_SeigToken *SeigTokenFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*SeigTokenOwnershipTransferredIterator, error) { 8112 8113 var previousOwnerRule []interface{} 8114 for _, previousOwnerItem := range previousOwner { 8115 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 8116 } 8117 var newOwnerRule []interface{} 8118 for _, newOwnerItem := range newOwner { 8119 newOwnerRule = append(newOwnerRule, newOwnerItem) 8120 } 8121 8122 logs, sub, err := _SeigToken.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 8123 if err != nil { 8124 return nil, err 8125 } 8126 return &SeigTokenOwnershipTransferredIterator{contract: _SeigToken.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 8127 } 8128 8129 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 8130 // 8131 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 8132 func (_SeigToken *SeigTokenFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *SeigTokenOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 8133 8134 var previousOwnerRule []interface{} 8135 for _, previousOwnerItem := range previousOwner { 8136 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 8137 } 8138 var newOwnerRule []interface{} 8139 for _, newOwnerItem := range newOwner { 8140 newOwnerRule = append(newOwnerRule, newOwnerItem) 8141 } 8142 8143 logs, sub, err := _SeigToken.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 8144 if err != nil { 8145 return nil, err 8146 } 8147 return event.NewSubscription(func(quit <-chan struct{}) error { 8148 defer sub.Unsubscribe() 8149 for { 8150 select { 8151 case log := <-logs: 8152 // New log arrived, parse the event and forward to the user 8153 event := new(SeigTokenOwnershipTransferred) 8154 if err := _SeigToken.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 8155 return err 8156 } 8157 event.Raw = log 8158 8159 select { 8160 case sink <- event: 8161 case err := <-sub.Err(): 8162 return err 8163 case <-quit: 8164 return nil 8165 } 8166 case err := <-sub.Err(): 8167 return err 8168 case <-quit: 8169 return nil 8170 } 8171 } 8172 }), nil 8173 } 8174 8175 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 8176 // 8177 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 8178 func (_SeigToken *SeigTokenFilterer) ParseOwnershipTransferred(log types.Log) (*SeigTokenOwnershipTransferred, error) { 8179 event := new(SeigTokenOwnershipTransferred) 8180 if err := _SeigToken.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 8181 return nil, err 8182 } 8183 return event, nil 8184 } 8185 8186 // 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. 8187 type SeigTokenTransferIterator struct { 8188 Event *SeigTokenTransfer // Event containing the contract specifics and raw log 8189 8190 contract *bind.BoundContract // Generic contract to use for unpacking event data 8191 event string // Event name to use for unpacking event data 8192 8193 logs chan types.Log // Log channel receiving the found contract events 8194 sub ethereum.Subscription // Subscription for errors, completion and termination 8195 done bool // Whether the subscription completed delivering logs 8196 fail error // Occurred error to stop iteration 8197 } 8198 8199 // Next advances the iterator to the subsequent event, returning whether there 8200 // are any more events found. In case of a retrieval or parsing error, false is 8201 // returned and Error() can be queried for the exact failure. 8202 func (it *SeigTokenTransferIterator) Next() bool { 8203 // If the iterator failed, stop iterating 8204 if it.fail != nil { 8205 return false 8206 } 8207 // If the iterator completed, deliver directly whatever's available 8208 if it.done { 8209 select { 8210 case log := <-it.logs: 8211 it.Event = new(SeigTokenTransfer) 8212 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 8213 it.fail = err 8214 return false 8215 } 8216 it.Event.Raw = log 8217 return true 8218 8219 default: 8220 return false 8221 } 8222 } 8223 // Iterator still in progress, wait for either a data or an error event 8224 select { 8225 case log := <-it.logs: 8226 it.Event = new(SeigTokenTransfer) 8227 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 8228 it.fail = err 8229 return false 8230 } 8231 it.Event.Raw = log 8232 return true 8233 8234 case err := <-it.sub.Err(): 8235 it.done = true 8236 it.fail = err 8237 return it.Next() 8238 } 8239 } 8240 8241 // Error returns any retrieval or parsing error occurred during filtering. 8242 func (it *SeigTokenTransferIterator) Error() error { 8243 return it.fail 8244 } 8245 8246 // Close terminates the iteration process, releasing any pending underlying 8247 // resources. 8248 func (it *SeigTokenTransferIterator) Close() error { 8249 it.sub.Unsubscribe() 8250 return nil 8251 } 8252 8253 // SeigTokenTransfer represents a Transfer event raised by the SeigToken contract. 8254 type SeigTokenTransfer struct { 8255 From common.Address 8256 To common.Address 8257 Value *big.Int 8258 Raw types.Log // Blockchain specific contextual infos 8259 } 8260 8261 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 8262 // 8263 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 8264 func (_SeigToken *SeigTokenFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*SeigTokenTransferIterator, error) { 8265 8266 var fromRule []interface{} 8267 for _, fromItem := range from { 8268 fromRule = append(fromRule, fromItem) 8269 } 8270 var toRule []interface{} 8271 for _, toItem := range to { 8272 toRule = append(toRule, toItem) 8273 } 8274 8275 logs, sub, err := _SeigToken.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 8276 if err != nil { 8277 return nil, err 8278 } 8279 return &SeigTokenTransferIterator{contract: _SeigToken.contract, event: "Transfer", logs: logs, sub: sub}, nil 8280 } 8281 8282 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 8283 // 8284 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 8285 func (_SeigToken *SeigTokenFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *SeigTokenTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 8286 8287 var fromRule []interface{} 8288 for _, fromItem := range from { 8289 fromRule = append(fromRule, fromItem) 8290 } 8291 var toRule []interface{} 8292 for _, toItem := range to { 8293 toRule = append(toRule, toItem) 8294 } 8295 8296 logs, sub, err := _SeigToken.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 8297 if err != nil { 8298 return nil, err 8299 } 8300 return event.NewSubscription(func(quit <-chan struct{}) error { 8301 defer sub.Unsubscribe() 8302 for { 8303 select { 8304 case log := <-logs: 8305 // New log arrived, parse the event and forward to the user 8306 event := new(SeigTokenTransfer) 8307 if err := _SeigToken.contract.UnpackLog(event, "Transfer", log); err != nil { 8308 return err 8309 } 8310 event.Raw = log 8311 8312 select { 8313 case sink <- event: 8314 case err := <-sub.Err(): 8315 return err 8316 case <-quit: 8317 return nil 8318 } 8319 case err := <-sub.Err(): 8320 return err 8321 case <-quit: 8322 return nil 8323 } 8324 } 8325 }), nil 8326 } 8327 8328 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 8329 // 8330 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 8331 func (_SeigToken *SeigTokenFilterer) ParseTransfer(log types.Log) (*SeigTokenTransfer, error) { 8332 event := new(SeigTokenTransfer) 8333 if err := _SeigToken.contract.UnpackLog(event, "Transfer", log); err != nil { 8334 return nil, err 8335 } 8336 return event, nil 8337 } 8338 8339 // TONABI is the input ABI used to generate the binding from. 8340 const TONABI = "[{\"inputs\":[],\"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\":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\":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\":[],\"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\"},{\"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\"}]" 8341 8342 // TONFuncSigs maps the 4-byte function signature to its string representation. 8343 var TONFuncSigs = map[string]string{ 8344 "6cd28f9a": "INTERFACE_ID_ON_APPROVE()", 8345 "983b2d56": "addMinter(address)", 8346 "dd62ed3e": "allowance(address,address)", 8347 "095ea7b3": "approve(address,uint256)", 8348 "cae9ca51": "approveAndCall(address,uint256,bytes)", 8349 "70a08231": "balanceOf(address)", 8350 "313ce567": "decimals()", 8351 "a457c2d7": "decreaseAllowance(address,uint256)", 8352 "39509351": "increaseAllowance(address,uint256)", 8353 "aa271e1a": "isMinter(address)", 8354 "8f32d59b": "isOwner()", 8355 "40c10f19": "mint(address,uint256)", 8356 "06fdde03": "name()", 8357 "8da5cb5b": "owner()", 8358 "98650275": "renounceMinter()", 8359 "5f112c68": "renounceMinter(address)", 8360 "715018a6": "renounceOwnership()", 8361 "38bf3cfa": "renounceOwnership(address)", 8362 "41eb24bb": "renouncePauser(address)", 8363 "6fb7f558": "seigManager()", 8364 "7657f20a": "setSeigManager(address)", 8365 "95d89b41": "symbol()", 8366 "18160ddd": "totalSupply()", 8367 "a9059cbb": "transfer(address,uint256)", 8368 "23b872dd": "transferFrom(address,address,uint256)", 8369 "f2fde38b": "transferOwnership(address)", 8370 "6d435421": "transferOwnership(address,address)", 8371 } 8372 8373 // TONBin is the compiled bytecode used for deploying new contracts. 8374 var TONBin = "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" 8375 8376 // DeployTON deploys a new Ethereum contract, binding an instance of TON to it. 8377 func DeployTON(auth *bind.TransactOpts, backend bind.ContractBackend) (common.Address, *types.Transaction, *TON, error) { 8378 parsed, err := abi.JSON(strings.NewReader(TONABI)) 8379 if err != nil { 8380 return common.Address{}, nil, nil, err 8381 } 8382 8383 address, tx, contract, err := bind.DeployContract(auth, parsed, common.FromHex(TONBin), backend) 8384 if err != nil { 8385 return common.Address{}, nil, nil, err 8386 } 8387 return address, tx, &TON{TONCaller: TONCaller{contract: contract}, TONTransactor: TONTransactor{contract: contract}, TONFilterer: TONFilterer{contract: contract}}, nil 8388 } 8389 8390 // TON is an auto generated Go binding around an Ethereum contract. 8391 type TON struct { 8392 TONCaller // Read-only binding to the contract 8393 TONTransactor // Write-only binding to the contract 8394 TONFilterer // Log filterer for contract events 8395 } 8396 8397 // TONCaller is an auto generated read-only Go binding around an Ethereum contract. 8398 type TONCaller struct { 8399 contract *bind.BoundContract // Generic contract wrapper for the low level calls 8400 } 8401 8402 // TONTransactor is an auto generated write-only Go binding around an Ethereum contract. 8403 type TONTransactor struct { 8404 contract *bind.BoundContract // Generic contract wrapper for the low level calls 8405 } 8406 8407 // TONFilterer is an auto generated log filtering Go binding around an Ethereum contract events. 8408 type TONFilterer struct { 8409 contract *bind.BoundContract // Generic contract wrapper for the low level calls 8410 } 8411 8412 // TONSession is an auto generated Go binding around an Ethereum contract, 8413 // with pre-set call and transact options. 8414 type TONSession struct { 8415 Contract *TON // Generic contract binding to set the session for 8416 CallOpts bind.CallOpts // Call options to use throughout this session 8417 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 8418 } 8419 8420 // TONCallerSession is an auto generated read-only Go binding around an Ethereum contract, 8421 // with pre-set call options. 8422 type TONCallerSession struct { 8423 Contract *TONCaller // Generic contract caller binding to set the session for 8424 CallOpts bind.CallOpts // Call options to use throughout this session 8425 } 8426 8427 // TONTransactorSession is an auto generated write-only Go binding around an Ethereum contract, 8428 // with pre-set transact options. 8429 type TONTransactorSession struct { 8430 Contract *TONTransactor // Generic contract transactor binding to set the session for 8431 TransactOpts bind.TransactOpts // Transaction auth options to use throughout this session 8432 } 8433 8434 // TONRaw is an auto generated low-level Go binding around an Ethereum contract. 8435 type TONRaw struct { 8436 Contract *TON // Generic contract binding to access the raw methods on 8437 } 8438 8439 // TONCallerRaw is an auto generated low-level read-only Go binding around an Ethereum contract. 8440 type TONCallerRaw struct { 8441 Contract *TONCaller // Generic read-only contract binding to access the raw methods on 8442 } 8443 8444 // TONTransactorRaw is an auto generated low-level write-only Go binding around an Ethereum contract. 8445 type TONTransactorRaw struct { 8446 Contract *TONTransactor // Generic write-only contract binding to access the raw methods on 8447 } 8448 8449 // NewTON creates a new instance of TON, bound to a specific deployed contract. 8450 func NewTON(address common.Address, backend bind.ContractBackend) (*TON, error) { 8451 contract, err := bindTON(address, backend, backend, backend) 8452 if err != nil { 8453 return nil, err 8454 } 8455 return &TON{TONCaller: TONCaller{contract: contract}, TONTransactor: TONTransactor{contract: contract}, TONFilterer: TONFilterer{contract: contract}}, nil 8456 } 8457 8458 // NewTONCaller creates a new read-only instance of TON, bound to a specific deployed contract. 8459 func NewTONCaller(address common.Address, caller bind.ContractCaller) (*TONCaller, error) { 8460 contract, err := bindTON(address, caller, nil, nil) 8461 if err != nil { 8462 return nil, err 8463 } 8464 return &TONCaller{contract: contract}, nil 8465 } 8466 8467 // NewTONTransactor creates a new write-only instance of TON, bound to a specific deployed contract. 8468 func NewTONTransactor(address common.Address, transactor bind.ContractTransactor) (*TONTransactor, error) { 8469 contract, err := bindTON(address, nil, transactor, nil) 8470 if err != nil { 8471 return nil, err 8472 } 8473 return &TONTransactor{contract: contract}, nil 8474 } 8475 8476 // NewTONFilterer creates a new log filterer instance of TON, bound to a specific deployed contract. 8477 func NewTONFilterer(address common.Address, filterer bind.ContractFilterer) (*TONFilterer, error) { 8478 contract, err := bindTON(address, nil, nil, filterer) 8479 if err != nil { 8480 return nil, err 8481 } 8482 return &TONFilterer{contract: contract}, nil 8483 } 8484 8485 // bindTON binds a generic wrapper to an already deployed contract. 8486 func bindTON(address common.Address, caller bind.ContractCaller, transactor bind.ContractTransactor, filterer bind.ContractFilterer) (*bind.BoundContract, error) { 8487 parsed, err := abi.JSON(strings.NewReader(TONABI)) 8488 if err != nil { 8489 return nil, err 8490 } 8491 return bind.NewBoundContract(address, parsed, caller, transactor, filterer), nil 8492 } 8493 8494 // Call invokes the (constant) contract method with params as input values and 8495 // sets the output to result. The result type might be a single field for simple 8496 // returns, a slice of interfaces for anonymous returns and a struct for named 8497 // returns. 8498 func (_TON *TONRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 8499 return _TON.Contract.TONCaller.contract.Call(opts, result, method, params...) 8500 } 8501 8502 // Transfer initiates a plain transaction to move funds to the contract, calling 8503 // its default method if one is available. 8504 func (_TON *TONRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 8505 return _TON.Contract.TONTransactor.contract.Transfer(opts) 8506 } 8507 8508 // Transact invokes the (paid) contract method with params as input values. 8509 func (_TON *TONRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 8510 return _TON.Contract.TONTransactor.contract.Transact(opts, method, params...) 8511 } 8512 8513 // Call invokes the (constant) contract method with params as input values and 8514 // sets the output to result. The result type might be a single field for simple 8515 // returns, a slice of interfaces for anonymous returns and a struct for named 8516 // returns. 8517 func (_TON *TONCallerRaw) Call(opts *bind.CallOpts, result interface{}, method string, params ...interface{}) error { 8518 return _TON.Contract.contract.Call(opts, result, method, params...) 8519 } 8520 8521 // Transfer initiates a plain transaction to move funds to the contract, calling 8522 // its default method if one is available. 8523 func (_TON *TONTransactorRaw) Transfer(opts *bind.TransactOpts) (*types.Transaction, error) { 8524 return _TON.Contract.contract.Transfer(opts) 8525 } 8526 8527 // Transact invokes the (paid) contract method with params as input values. 8528 func (_TON *TONTransactorRaw) Transact(opts *bind.TransactOpts, method string, params ...interface{}) (*types.Transaction, error) { 8529 return _TON.Contract.contract.Transact(opts, method, params...) 8530 } 8531 8532 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 8533 // 8534 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 8535 func (_TON *TONCaller) INTERFACEIDONAPPROVE(opts *bind.CallOpts) ([4]byte, error) { 8536 var ( 8537 ret0 = new([4]byte) 8538 ) 8539 out := ret0 8540 err := _TON.contract.Call(opts, out, "INTERFACE_ID_ON_APPROVE") 8541 return *ret0, err 8542 } 8543 8544 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 8545 // 8546 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 8547 func (_TON *TONSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 8548 return _TON.Contract.INTERFACEIDONAPPROVE(&_TON.CallOpts) 8549 } 8550 8551 // INTERFACEIDONAPPROVE is a free data retrieval call binding the contract method 0x6cd28f9a. 8552 // 8553 // Solidity: function INTERFACE_ID_ON_APPROVE() constant returns(bytes4) 8554 func (_TON *TONCallerSession) INTERFACEIDONAPPROVE() ([4]byte, error) { 8555 return _TON.Contract.INTERFACEIDONAPPROVE(&_TON.CallOpts) 8556 } 8557 8558 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 8559 // 8560 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 8561 func (_TON *TONCaller) Allowance(opts *bind.CallOpts, owner common.Address, spender common.Address) (*big.Int, error) { 8562 var ( 8563 ret0 = new(*big.Int) 8564 ) 8565 out := ret0 8566 err := _TON.contract.Call(opts, out, "allowance", owner, spender) 8567 return *ret0, err 8568 } 8569 8570 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 8571 // 8572 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 8573 func (_TON *TONSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 8574 return _TON.Contract.Allowance(&_TON.CallOpts, owner, spender) 8575 } 8576 8577 // Allowance is a free data retrieval call binding the contract method 0xdd62ed3e. 8578 // 8579 // Solidity: function allowance(address owner, address spender) constant returns(uint256) 8580 func (_TON *TONCallerSession) Allowance(owner common.Address, spender common.Address) (*big.Int, error) { 8581 return _TON.Contract.Allowance(&_TON.CallOpts, owner, spender) 8582 } 8583 8584 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 8585 // 8586 // Solidity: function balanceOf(address account) constant returns(uint256) 8587 func (_TON *TONCaller) BalanceOf(opts *bind.CallOpts, account common.Address) (*big.Int, error) { 8588 var ( 8589 ret0 = new(*big.Int) 8590 ) 8591 out := ret0 8592 err := _TON.contract.Call(opts, out, "balanceOf", account) 8593 return *ret0, err 8594 } 8595 8596 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 8597 // 8598 // Solidity: function balanceOf(address account) constant returns(uint256) 8599 func (_TON *TONSession) BalanceOf(account common.Address) (*big.Int, error) { 8600 return _TON.Contract.BalanceOf(&_TON.CallOpts, account) 8601 } 8602 8603 // BalanceOf is a free data retrieval call binding the contract method 0x70a08231. 8604 // 8605 // Solidity: function balanceOf(address account) constant returns(uint256) 8606 func (_TON *TONCallerSession) BalanceOf(account common.Address) (*big.Int, error) { 8607 return _TON.Contract.BalanceOf(&_TON.CallOpts, account) 8608 } 8609 8610 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 8611 // 8612 // Solidity: function decimals() constant returns(uint8) 8613 func (_TON *TONCaller) Decimals(opts *bind.CallOpts) (uint8, error) { 8614 var ( 8615 ret0 = new(uint8) 8616 ) 8617 out := ret0 8618 err := _TON.contract.Call(opts, out, "decimals") 8619 return *ret0, err 8620 } 8621 8622 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 8623 // 8624 // Solidity: function decimals() constant returns(uint8) 8625 func (_TON *TONSession) Decimals() (uint8, error) { 8626 return _TON.Contract.Decimals(&_TON.CallOpts) 8627 } 8628 8629 // Decimals is a free data retrieval call binding the contract method 0x313ce567. 8630 // 8631 // Solidity: function decimals() constant returns(uint8) 8632 func (_TON *TONCallerSession) Decimals() (uint8, error) { 8633 return _TON.Contract.Decimals(&_TON.CallOpts) 8634 } 8635 8636 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 8637 // 8638 // Solidity: function isMinter(address account) constant returns(bool) 8639 func (_TON *TONCaller) IsMinter(opts *bind.CallOpts, account common.Address) (bool, error) { 8640 var ( 8641 ret0 = new(bool) 8642 ) 8643 out := ret0 8644 err := _TON.contract.Call(opts, out, "isMinter", account) 8645 return *ret0, err 8646 } 8647 8648 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 8649 // 8650 // Solidity: function isMinter(address account) constant returns(bool) 8651 func (_TON *TONSession) IsMinter(account common.Address) (bool, error) { 8652 return _TON.Contract.IsMinter(&_TON.CallOpts, account) 8653 } 8654 8655 // IsMinter is a free data retrieval call binding the contract method 0xaa271e1a. 8656 // 8657 // Solidity: function isMinter(address account) constant returns(bool) 8658 func (_TON *TONCallerSession) IsMinter(account common.Address) (bool, error) { 8659 return _TON.Contract.IsMinter(&_TON.CallOpts, account) 8660 } 8661 8662 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 8663 // 8664 // Solidity: function isOwner() constant returns(bool) 8665 func (_TON *TONCaller) IsOwner(opts *bind.CallOpts) (bool, error) { 8666 var ( 8667 ret0 = new(bool) 8668 ) 8669 out := ret0 8670 err := _TON.contract.Call(opts, out, "isOwner") 8671 return *ret0, err 8672 } 8673 8674 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 8675 // 8676 // Solidity: function isOwner() constant returns(bool) 8677 func (_TON *TONSession) IsOwner() (bool, error) { 8678 return _TON.Contract.IsOwner(&_TON.CallOpts) 8679 } 8680 8681 // IsOwner is a free data retrieval call binding the contract method 0x8f32d59b. 8682 // 8683 // Solidity: function isOwner() constant returns(bool) 8684 func (_TON *TONCallerSession) IsOwner() (bool, error) { 8685 return _TON.Contract.IsOwner(&_TON.CallOpts) 8686 } 8687 8688 // Name is a free data retrieval call binding the contract method 0x06fdde03. 8689 // 8690 // Solidity: function name() constant returns(string) 8691 func (_TON *TONCaller) Name(opts *bind.CallOpts) (string, error) { 8692 var ( 8693 ret0 = new(string) 8694 ) 8695 out := ret0 8696 err := _TON.contract.Call(opts, out, "name") 8697 return *ret0, err 8698 } 8699 8700 // Name is a free data retrieval call binding the contract method 0x06fdde03. 8701 // 8702 // Solidity: function name() constant returns(string) 8703 func (_TON *TONSession) Name() (string, error) { 8704 return _TON.Contract.Name(&_TON.CallOpts) 8705 } 8706 8707 // Name is a free data retrieval call binding the contract method 0x06fdde03. 8708 // 8709 // Solidity: function name() constant returns(string) 8710 func (_TON *TONCallerSession) Name() (string, error) { 8711 return _TON.Contract.Name(&_TON.CallOpts) 8712 } 8713 8714 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 8715 // 8716 // Solidity: function owner() constant returns(address) 8717 func (_TON *TONCaller) Owner(opts *bind.CallOpts) (common.Address, error) { 8718 var ( 8719 ret0 = new(common.Address) 8720 ) 8721 out := ret0 8722 err := _TON.contract.Call(opts, out, "owner") 8723 return *ret0, err 8724 } 8725 8726 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 8727 // 8728 // Solidity: function owner() constant returns(address) 8729 func (_TON *TONSession) Owner() (common.Address, error) { 8730 return _TON.Contract.Owner(&_TON.CallOpts) 8731 } 8732 8733 // Owner is a free data retrieval call binding the contract method 0x8da5cb5b. 8734 // 8735 // Solidity: function owner() constant returns(address) 8736 func (_TON *TONCallerSession) Owner() (common.Address, error) { 8737 return _TON.Contract.Owner(&_TON.CallOpts) 8738 } 8739 8740 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 8741 // 8742 // Solidity: function seigManager() constant returns(address) 8743 func (_TON *TONCaller) SeigManager(opts *bind.CallOpts) (common.Address, error) { 8744 var ( 8745 ret0 = new(common.Address) 8746 ) 8747 out := ret0 8748 err := _TON.contract.Call(opts, out, "seigManager") 8749 return *ret0, err 8750 } 8751 8752 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 8753 // 8754 // Solidity: function seigManager() constant returns(address) 8755 func (_TON *TONSession) SeigManager() (common.Address, error) { 8756 return _TON.Contract.SeigManager(&_TON.CallOpts) 8757 } 8758 8759 // SeigManager is a free data retrieval call binding the contract method 0x6fb7f558. 8760 // 8761 // Solidity: function seigManager() constant returns(address) 8762 func (_TON *TONCallerSession) SeigManager() (common.Address, error) { 8763 return _TON.Contract.SeigManager(&_TON.CallOpts) 8764 } 8765 8766 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 8767 // 8768 // Solidity: function symbol() constant returns(string) 8769 func (_TON *TONCaller) Symbol(opts *bind.CallOpts) (string, error) { 8770 var ( 8771 ret0 = new(string) 8772 ) 8773 out := ret0 8774 err := _TON.contract.Call(opts, out, "symbol") 8775 return *ret0, err 8776 } 8777 8778 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 8779 // 8780 // Solidity: function symbol() constant returns(string) 8781 func (_TON *TONSession) Symbol() (string, error) { 8782 return _TON.Contract.Symbol(&_TON.CallOpts) 8783 } 8784 8785 // Symbol is a free data retrieval call binding the contract method 0x95d89b41. 8786 // 8787 // Solidity: function symbol() constant returns(string) 8788 func (_TON *TONCallerSession) Symbol() (string, error) { 8789 return _TON.Contract.Symbol(&_TON.CallOpts) 8790 } 8791 8792 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 8793 // 8794 // Solidity: function totalSupply() constant returns(uint256) 8795 func (_TON *TONCaller) TotalSupply(opts *bind.CallOpts) (*big.Int, error) { 8796 var ( 8797 ret0 = new(*big.Int) 8798 ) 8799 out := ret0 8800 err := _TON.contract.Call(opts, out, "totalSupply") 8801 return *ret0, err 8802 } 8803 8804 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 8805 // 8806 // Solidity: function totalSupply() constant returns(uint256) 8807 func (_TON *TONSession) TotalSupply() (*big.Int, error) { 8808 return _TON.Contract.TotalSupply(&_TON.CallOpts) 8809 } 8810 8811 // TotalSupply is a free data retrieval call binding the contract method 0x18160ddd. 8812 // 8813 // Solidity: function totalSupply() constant returns(uint256) 8814 func (_TON *TONCallerSession) TotalSupply() (*big.Int, error) { 8815 return _TON.Contract.TotalSupply(&_TON.CallOpts) 8816 } 8817 8818 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 8819 // 8820 // Solidity: function addMinter(address account) returns() 8821 func (_TON *TONTransactor) AddMinter(opts *bind.TransactOpts, account common.Address) (*types.Transaction, error) { 8822 return _TON.contract.Transact(opts, "addMinter", account) 8823 } 8824 8825 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 8826 // 8827 // Solidity: function addMinter(address account) returns() 8828 func (_TON *TONSession) AddMinter(account common.Address) (*types.Transaction, error) { 8829 return _TON.Contract.AddMinter(&_TON.TransactOpts, account) 8830 } 8831 8832 // AddMinter is a paid mutator transaction binding the contract method 0x983b2d56. 8833 // 8834 // Solidity: function addMinter(address account) returns() 8835 func (_TON *TONTransactorSession) AddMinter(account common.Address) (*types.Transaction, error) { 8836 return _TON.Contract.AddMinter(&_TON.TransactOpts, account) 8837 } 8838 8839 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 8840 // 8841 // Solidity: function approve(address spender, uint256 amount) returns(bool) 8842 func (_TON *TONTransactor) Approve(opts *bind.TransactOpts, spender common.Address, amount *big.Int) (*types.Transaction, error) { 8843 return _TON.contract.Transact(opts, "approve", spender, amount) 8844 } 8845 8846 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 8847 // 8848 // Solidity: function approve(address spender, uint256 amount) returns(bool) 8849 func (_TON *TONSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 8850 return _TON.Contract.Approve(&_TON.TransactOpts, spender, amount) 8851 } 8852 8853 // Approve is a paid mutator transaction binding the contract method 0x095ea7b3. 8854 // 8855 // Solidity: function approve(address spender, uint256 amount) returns(bool) 8856 func (_TON *TONTransactorSession) Approve(spender common.Address, amount *big.Int) (*types.Transaction, error) { 8857 return _TON.Contract.Approve(&_TON.TransactOpts, spender, amount) 8858 } 8859 8860 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 8861 // 8862 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 8863 func (_TON *TONTransactor) ApproveAndCall(opts *bind.TransactOpts, spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 8864 return _TON.contract.Transact(opts, "approveAndCall", spender, amount, data) 8865 } 8866 8867 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 8868 // 8869 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 8870 func (_TON *TONSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 8871 return _TON.Contract.ApproveAndCall(&_TON.TransactOpts, spender, amount, data) 8872 } 8873 8874 // ApproveAndCall is a paid mutator transaction binding the contract method 0xcae9ca51. 8875 // 8876 // Solidity: function approveAndCall(address spender, uint256 amount, bytes data) returns(bool) 8877 func (_TON *TONTransactorSession) ApproveAndCall(spender common.Address, amount *big.Int, data []byte) (*types.Transaction, error) { 8878 return _TON.Contract.ApproveAndCall(&_TON.TransactOpts, spender, amount, data) 8879 } 8880 8881 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 8882 // 8883 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 8884 func (_TON *TONTransactor) DecreaseAllowance(opts *bind.TransactOpts, spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 8885 return _TON.contract.Transact(opts, "decreaseAllowance", spender, subtractedValue) 8886 } 8887 8888 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 8889 // 8890 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 8891 func (_TON *TONSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 8892 return _TON.Contract.DecreaseAllowance(&_TON.TransactOpts, spender, subtractedValue) 8893 } 8894 8895 // DecreaseAllowance is a paid mutator transaction binding the contract method 0xa457c2d7. 8896 // 8897 // Solidity: function decreaseAllowance(address spender, uint256 subtractedValue) returns(bool) 8898 func (_TON *TONTransactorSession) DecreaseAllowance(spender common.Address, subtractedValue *big.Int) (*types.Transaction, error) { 8899 return _TON.Contract.DecreaseAllowance(&_TON.TransactOpts, spender, subtractedValue) 8900 } 8901 8902 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 8903 // 8904 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 8905 func (_TON *TONTransactor) IncreaseAllowance(opts *bind.TransactOpts, spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 8906 return _TON.contract.Transact(opts, "increaseAllowance", spender, addedValue) 8907 } 8908 8909 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 8910 // 8911 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 8912 func (_TON *TONSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 8913 return _TON.Contract.IncreaseAllowance(&_TON.TransactOpts, spender, addedValue) 8914 } 8915 8916 // IncreaseAllowance is a paid mutator transaction binding the contract method 0x39509351. 8917 // 8918 // Solidity: function increaseAllowance(address spender, uint256 addedValue) returns(bool) 8919 func (_TON *TONTransactorSession) IncreaseAllowance(spender common.Address, addedValue *big.Int) (*types.Transaction, error) { 8920 return _TON.Contract.IncreaseAllowance(&_TON.TransactOpts, spender, addedValue) 8921 } 8922 8923 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 8924 // 8925 // Solidity: function mint(address account, uint256 amount) returns(bool) 8926 func (_TON *TONTransactor) Mint(opts *bind.TransactOpts, account common.Address, amount *big.Int) (*types.Transaction, error) { 8927 return _TON.contract.Transact(opts, "mint", account, amount) 8928 } 8929 8930 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 8931 // 8932 // Solidity: function mint(address account, uint256 amount) returns(bool) 8933 func (_TON *TONSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { 8934 return _TON.Contract.Mint(&_TON.TransactOpts, account, amount) 8935 } 8936 8937 // Mint is a paid mutator transaction binding the contract method 0x40c10f19. 8938 // 8939 // Solidity: function mint(address account, uint256 amount) returns(bool) 8940 func (_TON *TONTransactorSession) Mint(account common.Address, amount *big.Int) (*types.Transaction, error) { 8941 return _TON.Contract.Mint(&_TON.TransactOpts, account, amount) 8942 } 8943 8944 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 8945 // 8946 // Solidity: function renounceMinter(address target) returns() 8947 func (_TON *TONTransactor) RenounceMinter(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 8948 return _TON.contract.Transact(opts, "renounceMinter", target) 8949 } 8950 8951 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 8952 // 8953 // Solidity: function renounceMinter(address target) returns() 8954 func (_TON *TONSession) RenounceMinter(target common.Address) (*types.Transaction, error) { 8955 return _TON.Contract.RenounceMinter(&_TON.TransactOpts, target) 8956 } 8957 8958 // RenounceMinter is a paid mutator transaction binding the contract method 0x5f112c68. 8959 // 8960 // Solidity: function renounceMinter(address target) returns() 8961 func (_TON *TONTransactorSession) RenounceMinter(target common.Address) (*types.Transaction, error) { 8962 return _TON.Contract.RenounceMinter(&_TON.TransactOpts, target) 8963 } 8964 8965 // RenounceMinter0 is a paid mutator transaction binding the contract method 0x98650275. 8966 // 8967 // Solidity: function renounceMinter() returns() 8968 func (_TON *TONTransactor) RenounceMinter0(opts *bind.TransactOpts) (*types.Transaction, error) { 8969 return _TON.contract.Transact(opts, "renounceMinter0") 8970 } 8971 8972 // RenounceMinter0 is a paid mutator transaction binding the contract method 0x98650275. 8973 // 8974 // Solidity: function renounceMinter() returns() 8975 func (_TON *TONSession) RenounceMinter0() (*types.Transaction, error) { 8976 return _TON.Contract.RenounceMinter0(&_TON.TransactOpts) 8977 } 8978 8979 // RenounceMinter0 is a paid mutator transaction binding the contract method 0x98650275. 8980 // 8981 // Solidity: function renounceMinter() returns() 8982 func (_TON *TONTransactorSession) RenounceMinter0() (*types.Transaction, error) { 8983 return _TON.Contract.RenounceMinter0(&_TON.TransactOpts) 8984 } 8985 8986 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 8987 // 8988 // Solidity: function renounceOwnership(address target) returns() 8989 func (_TON *TONTransactor) RenounceOwnership(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 8990 return _TON.contract.Transact(opts, "renounceOwnership", target) 8991 } 8992 8993 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 8994 // 8995 // Solidity: function renounceOwnership(address target) returns() 8996 func (_TON *TONSession) RenounceOwnership(target common.Address) (*types.Transaction, error) { 8997 return _TON.Contract.RenounceOwnership(&_TON.TransactOpts, target) 8998 } 8999 9000 // RenounceOwnership is a paid mutator transaction binding the contract method 0x38bf3cfa. 9001 // 9002 // Solidity: function renounceOwnership(address target) returns() 9003 func (_TON *TONTransactorSession) RenounceOwnership(target common.Address) (*types.Transaction, error) { 9004 return _TON.Contract.RenounceOwnership(&_TON.TransactOpts, target) 9005 } 9006 9007 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 9008 // 9009 // Solidity: function renounceOwnership() returns() 9010 func (_TON *TONTransactor) RenounceOwnership0(opts *bind.TransactOpts) (*types.Transaction, error) { 9011 return _TON.contract.Transact(opts, "renounceOwnership0") 9012 } 9013 9014 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 9015 // 9016 // Solidity: function renounceOwnership() returns() 9017 func (_TON *TONSession) RenounceOwnership0() (*types.Transaction, error) { 9018 return _TON.Contract.RenounceOwnership0(&_TON.TransactOpts) 9019 } 9020 9021 // RenounceOwnership0 is a paid mutator transaction binding the contract method 0x715018a6. 9022 // 9023 // Solidity: function renounceOwnership() returns() 9024 func (_TON *TONTransactorSession) RenounceOwnership0() (*types.Transaction, error) { 9025 return _TON.Contract.RenounceOwnership0(&_TON.TransactOpts) 9026 } 9027 9028 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 9029 // 9030 // Solidity: function renouncePauser(address target) returns() 9031 func (_TON *TONTransactor) RenouncePauser(opts *bind.TransactOpts, target common.Address) (*types.Transaction, error) { 9032 return _TON.contract.Transact(opts, "renouncePauser", target) 9033 } 9034 9035 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 9036 // 9037 // Solidity: function renouncePauser(address target) returns() 9038 func (_TON *TONSession) RenouncePauser(target common.Address) (*types.Transaction, error) { 9039 return _TON.Contract.RenouncePauser(&_TON.TransactOpts, target) 9040 } 9041 9042 // RenouncePauser is a paid mutator transaction binding the contract method 0x41eb24bb. 9043 // 9044 // Solidity: function renouncePauser(address target) returns() 9045 func (_TON *TONTransactorSession) RenouncePauser(target common.Address) (*types.Transaction, error) { 9046 return _TON.Contract.RenouncePauser(&_TON.TransactOpts, target) 9047 } 9048 9049 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 9050 // 9051 // Solidity: function setSeigManager(address _seigManager) returns() 9052 func (_TON *TONTransactor) SetSeigManager(opts *bind.TransactOpts, _seigManager common.Address) (*types.Transaction, error) { 9053 return _TON.contract.Transact(opts, "setSeigManager", _seigManager) 9054 } 9055 9056 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 9057 // 9058 // Solidity: function setSeigManager(address _seigManager) returns() 9059 func (_TON *TONSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) { 9060 return _TON.Contract.SetSeigManager(&_TON.TransactOpts, _seigManager) 9061 } 9062 9063 // SetSeigManager is a paid mutator transaction binding the contract method 0x7657f20a. 9064 // 9065 // Solidity: function setSeigManager(address _seigManager) returns() 9066 func (_TON *TONTransactorSession) SetSeigManager(_seigManager common.Address) (*types.Transaction, error) { 9067 return _TON.Contract.SetSeigManager(&_TON.TransactOpts, _seigManager) 9068 } 9069 9070 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 9071 // 9072 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 9073 func (_TON *TONTransactor) Transfer(opts *bind.TransactOpts, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 9074 return _TON.contract.Transact(opts, "transfer", recipient, amount) 9075 } 9076 9077 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 9078 // 9079 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 9080 func (_TON *TONSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 9081 return _TON.Contract.Transfer(&_TON.TransactOpts, recipient, amount) 9082 } 9083 9084 // Transfer is a paid mutator transaction binding the contract method 0xa9059cbb. 9085 // 9086 // Solidity: function transfer(address recipient, uint256 amount) returns(bool) 9087 func (_TON *TONTransactorSession) Transfer(recipient common.Address, amount *big.Int) (*types.Transaction, error) { 9088 return _TON.Contract.Transfer(&_TON.TransactOpts, recipient, amount) 9089 } 9090 9091 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 9092 // 9093 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 9094 func (_TON *TONTransactor) TransferFrom(opts *bind.TransactOpts, sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 9095 return _TON.contract.Transact(opts, "transferFrom", sender, recipient, amount) 9096 } 9097 9098 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 9099 // 9100 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 9101 func (_TON *TONSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 9102 return _TON.Contract.TransferFrom(&_TON.TransactOpts, sender, recipient, amount) 9103 } 9104 9105 // TransferFrom is a paid mutator transaction binding the contract method 0x23b872dd. 9106 // 9107 // Solidity: function transferFrom(address sender, address recipient, uint256 amount) returns(bool) 9108 func (_TON *TONTransactorSession) TransferFrom(sender common.Address, recipient common.Address, amount *big.Int) (*types.Transaction, error) { 9109 return _TON.Contract.TransferFrom(&_TON.TransactOpts, sender, recipient, amount) 9110 } 9111 9112 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 9113 // 9114 // Solidity: function transferOwnership(address target, address newOwner) returns() 9115 func (_TON *TONTransactor) TransferOwnership(opts *bind.TransactOpts, target common.Address, newOwner common.Address) (*types.Transaction, error) { 9116 return _TON.contract.Transact(opts, "transferOwnership", target, newOwner) 9117 } 9118 9119 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 9120 // 9121 // Solidity: function transferOwnership(address target, address newOwner) returns() 9122 func (_TON *TONSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) { 9123 return _TON.Contract.TransferOwnership(&_TON.TransactOpts, target, newOwner) 9124 } 9125 9126 // TransferOwnership is a paid mutator transaction binding the contract method 0x6d435421. 9127 // 9128 // Solidity: function transferOwnership(address target, address newOwner) returns() 9129 func (_TON *TONTransactorSession) TransferOwnership(target common.Address, newOwner common.Address) (*types.Transaction, error) { 9130 return _TON.Contract.TransferOwnership(&_TON.TransactOpts, target, newOwner) 9131 } 9132 9133 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 9134 // 9135 // Solidity: function transferOwnership(address newOwner) returns() 9136 func (_TON *TONTransactor) TransferOwnership0(opts *bind.TransactOpts, newOwner common.Address) (*types.Transaction, error) { 9137 return _TON.contract.Transact(opts, "transferOwnership0", newOwner) 9138 } 9139 9140 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 9141 // 9142 // Solidity: function transferOwnership(address newOwner) returns() 9143 func (_TON *TONSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) { 9144 return _TON.Contract.TransferOwnership0(&_TON.TransactOpts, newOwner) 9145 } 9146 9147 // TransferOwnership0 is a paid mutator transaction binding the contract method 0xf2fde38b. 9148 // 9149 // Solidity: function transferOwnership(address newOwner) returns() 9150 func (_TON *TONTransactorSession) TransferOwnership0(newOwner common.Address) (*types.Transaction, error) { 9151 return _TON.Contract.TransferOwnership0(&_TON.TransactOpts, newOwner) 9152 } 9153 9154 // TONApprovalIterator is returned from FilterApproval and is used to iterate over the raw logs and unpacked data for Approval events raised by the TON contract. 9155 type TONApprovalIterator struct { 9156 Event *TONApproval // Event containing the contract specifics and raw log 9157 9158 contract *bind.BoundContract // Generic contract to use for unpacking event data 9159 event string // Event name to use for unpacking event data 9160 9161 logs chan types.Log // Log channel receiving the found contract events 9162 sub ethereum.Subscription // Subscription for errors, completion and termination 9163 done bool // Whether the subscription completed delivering logs 9164 fail error // Occurred error to stop iteration 9165 } 9166 9167 // Next advances the iterator to the subsequent event, returning whether there 9168 // are any more events found. In case of a retrieval or parsing error, false is 9169 // returned and Error() can be queried for the exact failure. 9170 func (it *TONApprovalIterator) Next() bool { 9171 // If the iterator failed, stop iterating 9172 if it.fail != nil { 9173 return false 9174 } 9175 // If the iterator completed, deliver directly whatever's available 9176 if it.done { 9177 select { 9178 case log := <-it.logs: 9179 it.Event = new(TONApproval) 9180 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 9181 it.fail = err 9182 return false 9183 } 9184 it.Event.Raw = log 9185 return true 9186 9187 default: 9188 return false 9189 } 9190 } 9191 // Iterator still in progress, wait for either a data or an error event 9192 select { 9193 case log := <-it.logs: 9194 it.Event = new(TONApproval) 9195 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 9196 it.fail = err 9197 return false 9198 } 9199 it.Event.Raw = log 9200 return true 9201 9202 case err := <-it.sub.Err(): 9203 it.done = true 9204 it.fail = err 9205 return it.Next() 9206 } 9207 } 9208 9209 // Error returns any retrieval or parsing error occurred during filtering. 9210 func (it *TONApprovalIterator) Error() error { 9211 return it.fail 9212 } 9213 9214 // Close terminates the iteration process, releasing any pending underlying 9215 // resources. 9216 func (it *TONApprovalIterator) Close() error { 9217 it.sub.Unsubscribe() 9218 return nil 9219 } 9220 9221 // TONApproval represents a Approval event raised by the TON contract. 9222 type TONApproval struct { 9223 Owner common.Address 9224 Spender common.Address 9225 Value *big.Int 9226 Raw types.Log // Blockchain specific contextual infos 9227 } 9228 9229 // FilterApproval is a free log retrieval operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 9230 // 9231 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 9232 func (_TON *TONFilterer) FilterApproval(opts *bind.FilterOpts, owner []common.Address, spender []common.Address) (*TONApprovalIterator, error) { 9233 9234 var ownerRule []interface{} 9235 for _, ownerItem := range owner { 9236 ownerRule = append(ownerRule, ownerItem) 9237 } 9238 var spenderRule []interface{} 9239 for _, spenderItem := range spender { 9240 spenderRule = append(spenderRule, spenderItem) 9241 } 9242 9243 logs, sub, err := _TON.contract.FilterLogs(opts, "Approval", ownerRule, spenderRule) 9244 if err != nil { 9245 return nil, err 9246 } 9247 return &TONApprovalIterator{contract: _TON.contract, event: "Approval", logs: logs, sub: sub}, nil 9248 } 9249 9250 // WatchApproval is a free log subscription operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 9251 // 9252 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 9253 func (_TON *TONFilterer) WatchApproval(opts *bind.WatchOpts, sink chan<- *TONApproval, owner []common.Address, spender []common.Address) (event.Subscription, error) { 9254 9255 var ownerRule []interface{} 9256 for _, ownerItem := range owner { 9257 ownerRule = append(ownerRule, ownerItem) 9258 } 9259 var spenderRule []interface{} 9260 for _, spenderItem := range spender { 9261 spenderRule = append(spenderRule, spenderItem) 9262 } 9263 9264 logs, sub, err := _TON.contract.WatchLogs(opts, "Approval", ownerRule, spenderRule) 9265 if err != nil { 9266 return nil, err 9267 } 9268 return event.NewSubscription(func(quit <-chan struct{}) error { 9269 defer sub.Unsubscribe() 9270 for { 9271 select { 9272 case log := <-logs: 9273 // New log arrived, parse the event and forward to the user 9274 event := new(TONApproval) 9275 if err := _TON.contract.UnpackLog(event, "Approval", log); err != nil { 9276 return err 9277 } 9278 event.Raw = log 9279 9280 select { 9281 case sink <- event: 9282 case err := <-sub.Err(): 9283 return err 9284 case <-quit: 9285 return nil 9286 } 9287 case err := <-sub.Err(): 9288 return err 9289 case <-quit: 9290 return nil 9291 } 9292 } 9293 }), nil 9294 } 9295 9296 // ParseApproval is a log parse operation binding the contract event 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925. 9297 // 9298 // Solidity: event Approval(address indexed owner, address indexed spender, uint256 value) 9299 func (_TON *TONFilterer) ParseApproval(log types.Log) (*TONApproval, error) { 9300 event := new(TONApproval) 9301 if err := _TON.contract.UnpackLog(event, "Approval", log); err != nil { 9302 return nil, err 9303 } 9304 return event, nil 9305 } 9306 9307 // TONMinterAddedIterator is returned from FilterMinterAdded and is used to iterate over the raw logs and unpacked data for MinterAdded events raised by the TON contract. 9308 type TONMinterAddedIterator struct { 9309 Event *TONMinterAdded // Event containing the contract specifics and raw log 9310 9311 contract *bind.BoundContract // Generic contract to use for unpacking event data 9312 event string // Event name to use for unpacking event data 9313 9314 logs chan types.Log // Log channel receiving the found contract events 9315 sub ethereum.Subscription // Subscription for errors, completion and termination 9316 done bool // Whether the subscription completed delivering logs 9317 fail error // Occurred error to stop iteration 9318 } 9319 9320 // Next advances the iterator to the subsequent event, returning whether there 9321 // are any more events found. In case of a retrieval or parsing error, false is 9322 // returned and Error() can be queried for the exact failure. 9323 func (it *TONMinterAddedIterator) Next() bool { 9324 // If the iterator failed, stop iterating 9325 if it.fail != nil { 9326 return false 9327 } 9328 // If the iterator completed, deliver directly whatever's available 9329 if it.done { 9330 select { 9331 case log := <-it.logs: 9332 it.Event = new(TONMinterAdded) 9333 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 9334 it.fail = err 9335 return false 9336 } 9337 it.Event.Raw = log 9338 return true 9339 9340 default: 9341 return false 9342 } 9343 } 9344 // Iterator still in progress, wait for either a data or an error event 9345 select { 9346 case log := <-it.logs: 9347 it.Event = new(TONMinterAdded) 9348 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 9349 it.fail = err 9350 return false 9351 } 9352 it.Event.Raw = log 9353 return true 9354 9355 case err := <-it.sub.Err(): 9356 it.done = true 9357 it.fail = err 9358 return it.Next() 9359 } 9360 } 9361 9362 // Error returns any retrieval or parsing error occurred during filtering. 9363 func (it *TONMinterAddedIterator) Error() error { 9364 return it.fail 9365 } 9366 9367 // Close terminates the iteration process, releasing any pending underlying 9368 // resources. 9369 func (it *TONMinterAddedIterator) Close() error { 9370 it.sub.Unsubscribe() 9371 return nil 9372 } 9373 9374 // TONMinterAdded represents a MinterAdded event raised by the TON contract. 9375 type TONMinterAdded struct { 9376 Account common.Address 9377 Raw types.Log // Blockchain specific contextual infos 9378 } 9379 9380 // FilterMinterAdded is a free log retrieval operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 9381 // 9382 // Solidity: event MinterAdded(address indexed account) 9383 func (_TON *TONFilterer) FilterMinterAdded(opts *bind.FilterOpts, account []common.Address) (*TONMinterAddedIterator, error) { 9384 9385 var accountRule []interface{} 9386 for _, accountItem := range account { 9387 accountRule = append(accountRule, accountItem) 9388 } 9389 9390 logs, sub, err := _TON.contract.FilterLogs(opts, "MinterAdded", accountRule) 9391 if err != nil { 9392 return nil, err 9393 } 9394 return &TONMinterAddedIterator{contract: _TON.contract, event: "MinterAdded", logs: logs, sub: sub}, nil 9395 } 9396 9397 // WatchMinterAdded is a free log subscription operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 9398 // 9399 // Solidity: event MinterAdded(address indexed account) 9400 func (_TON *TONFilterer) WatchMinterAdded(opts *bind.WatchOpts, sink chan<- *TONMinterAdded, account []common.Address) (event.Subscription, error) { 9401 9402 var accountRule []interface{} 9403 for _, accountItem := range account { 9404 accountRule = append(accountRule, accountItem) 9405 } 9406 9407 logs, sub, err := _TON.contract.WatchLogs(opts, "MinterAdded", accountRule) 9408 if err != nil { 9409 return nil, err 9410 } 9411 return event.NewSubscription(func(quit <-chan struct{}) error { 9412 defer sub.Unsubscribe() 9413 for { 9414 select { 9415 case log := <-logs: 9416 // New log arrived, parse the event and forward to the user 9417 event := new(TONMinterAdded) 9418 if err := _TON.contract.UnpackLog(event, "MinterAdded", log); err != nil { 9419 return err 9420 } 9421 event.Raw = log 9422 9423 select { 9424 case sink <- event: 9425 case err := <-sub.Err(): 9426 return err 9427 case <-quit: 9428 return nil 9429 } 9430 case err := <-sub.Err(): 9431 return err 9432 case <-quit: 9433 return nil 9434 } 9435 } 9436 }), nil 9437 } 9438 9439 // ParseMinterAdded is a log parse operation binding the contract event 0x6ae172837ea30b801fbfcdd4108aa1d5bf8ff775444fd70256b44e6bf3dfc3f6. 9440 // 9441 // Solidity: event MinterAdded(address indexed account) 9442 func (_TON *TONFilterer) ParseMinterAdded(log types.Log) (*TONMinterAdded, error) { 9443 event := new(TONMinterAdded) 9444 if err := _TON.contract.UnpackLog(event, "MinterAdded", log); err != nil { 9445 return nil, err 9446 } 9447 return event, nil 9448 } 9449 9450 // TONMinterRemovedIterator is returned from FilterMinterRemoved and is used to iterate over the raw logs and unpacked data for MinterRemoved events raised by the TON contract. 9451 type TONMinterRemovedIterator struct { 9452 Event *TONMinterRemoved // Event containing the contract specifics and raw log 9453 9454 contract *bind.BoundContract // Generic contract to use for unpacking event data 9455 event string // Event name to use for unpacking event data 9456 9457 logs chan types.Log // Log channel receiving the found contract events 9458 sub ethereum.Subscription // Subscription for errors, completion and termination 9459 done bool // Whether the subscription completed delivering logs 9460 fail error // Occurred error to stop iteration 9461 } 9462 9463 // Next advances the iterator to the subsequent event, returning whether there 9464 // are any more events found. In case of a retrieval or parsing error, false is 9465 // returned and Error() can be queried for the exact failure. 9466 func (it *TONMinterRemovedIterator) Next() bool { 9467 // If the iterator failed, stop iterating 9468 if it.fail != nil { 9469 return false 9470 } 9471 // If the iterator completed, deliver directly whatever's available 9472 if it.done { 9473 select { 9474 case log := <-it.logs: 9475 it.Event = new(TONMinterRemoved) 9476 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 9477 it.fail = err 9478 return false 9479 } 9480 it.Event.Raw = log 9481 return true 9482 9483 default: 9484 return false 9485 } 9486 } 9487 // Iterator still in progress, wait for either a data or an error event 9488 select { 9489 case log := <-it.logs: 9490 it.Event = new(TONMinterRemoved) 9491 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 9492 it.fail = err 9493 return false 9494 } 9495 it.Event.Raw = log 9496 return true 9497 9498 case err := <-it.sub.Err(): 9499 it.done = true 9500 it.fail = err 9501 return it.Next() 9502 } 9503 } 9504 9505 // Error returns any retrieval or parsing error occurred during filtering. 9506 func (it *TONMinterRemovedIterator) Error() error { 9507 return it.fail 9508 } 9509 9510 // Close terminates the iteration process, releasing any pending underlying 9511 // resources. 9512 func (it *TONMinterRemovedIterator) Close() error { 9513 it.sub.Unsubscribe() 9514 return nil 9515 } 9516 9517 // TONMinterRemoved represents a MinterRemoved event raised by the TON contract. 9518 type TONMinterRemoved struct { 9519 Account common.Address 9520 Raw types.Log // Blockchain specific contextual infos 9521 } 9522 9523 // FilterMinterRemoved is a free log retrieval operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 9524 // 9525 // Solidity: event MinterRemoved(address indexed account) 9526 func (_TON *TONFilterer) FilterMinterRemoved(opts *bind.FilterOpts, account []common.Address) (*TONMinterRemovedIterator, error) { 9527 9528 var accountRule []interface{} 9529 for _, accountItem := range account { 9530 accountRule = append(accountRule, accountItem) 9531 } 9532 9533 logs, sub, err := _TON.contract.FilterLogs(opts, "MinterRemoved", accountRule) 9534 if err != nil { 9535 return nil, err 9536 } 9537 return &TONMinterRemovedIterator{contract: _TON.contract, event: "MinterRemoved", logs: logs, sub: sub}, nil 9538 } 9539 9540 // WatchMinterRemoved is a free log subscription operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 9541 // 9542 // Solidity: event MinterRemoved(address indexed account) 9543 func (_TON *TONFilterer) WatchMinterRemoved(opts *bind.WatchOpts, sink chan<- *TONMinterRemoved, account []common.Address) (event.Subscription, error) { 9544 9545 var accountRule []interface{} 9546 for _, accountItem := range account { 9547 accountRule = append(accountRule, accountItem) 9548 } 9549 9550 logs, sub, err := _TON.contract.WatchLogs(opts, "MinterRemoved", accountRule) 9551 if err != nil { 9552 return nil, err 9553 } 9554 return event.NewSubscription(func(quit <-chan struct{}) error { 9555 defer sub.Unsubscribe() 9556 for { 9557 select { 9558 case log := <-logs: 9559 // New log arrived, parse the event and forward to the user 9560 event := new(TONMinterRemoved) 9561 if err := _TON.contract.UnpackLog(event, "MinterRemoved", log); err != nil { 9562 return err 9563 } 9564 event.Raw = log 9565 9566 select { 9567 case sink <- event: 9568 case err := <-sub.Err(): 9569 return err 9570 case <-quit: 9571 return nil 9572 } 9573 case err := <-sub.Err(): 9574 return err 9575 case <-quit: 9576 return nil 9577 } 9578 } 9579 }), nil 9580 } 9581 9582 // ParseMinterRemoved is a log parse operation binding the contract event 0xe94479a9f7e1952cc78f2d6baab678adc1b772d936c6583def489e524cb66692. 9583 // 9584 // Solidity: event MinterRemoved(address indexed account) 9585 func (_TON *TONFilterer) ParseMinterRemoved(log types.Log) (*TONMinterRemoved, error) { 9586 event := new(TONMinterRemoved) 9587 if err := _TON.contract.UnpackLog(event, "MinterRemoved", log); err != nil { 9588 return nil, err 9589 } 9590 return event, nil 9591 } 9592 9593 // TONOwnershipTransferredIterator is returned from FilterOwnershipTransferred and is used to iterate over the raw logs and unpacked data for OwnershipTransferred events raised by the TON contract. 9594 type TONOwnershipTransferredIterator struct { 9595 Event *TONOwnershipTransferred // Event containing the contract specifics and raw log 9596 9597 contract *bind.BoundContract // Generic contract to use for unpacking event data 9598 event string // Event name to use for unpacking event data 9599 9600 logs chan types.Log // Log channel receiving the found contract events 9601 sub ethereum.Subscription // Subscription for errors, completion and termination 9602 done bool // Whether the subscription completed delivering logs 9603 fail error // Occurred error to stop iteration 9604 } 9605 9606 // Next advances the iterator to the subsequent event, returning whether there 9607 // are any more events found. In case of a retrieval or parsing error, false is 9608 // returned and Error() can be queried for the exact failure. 9609 func (it *TONOwnershipTransferredIterator) Next() bool { 9610 // If the iterator failed, stop iterating 9611 if it.fail != nil { 9612 return false 9613 } 9614 // If the iterator completed, deliver directly whatever's available 9615 if it.done { 9616 select { 9617 case log := <-it.logs: 9618 it.Event = new(TONOwnershipTransferred) 9619 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 9620 it.fail = err 9621 return false 9622 } 9623 it.Event.Raw = log 9624 return true 9625 9626 default: 9627 return false 9628 } 9629 } 9630 // Iterator still in progress, wait for either a data or an error event 9631 select { 9632 case log := <-it.logs: 9633 it.Event = new(TONOwnershipTransferred) 9634 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 9635 it.fail = err 9636 return false 9637 } 9638 it.Event.Raw = log 9639 return true 9640 9641 case err := <-it.sub.Err(): 9642 it.done = true 9643 it.fail = err 9644 return it.Next() 9645 } 9646 } 9647 9648 // Error returns any retrieval or parsing error occurred during filtering. 9649 func (it *TONOwnershipTransferredIterator) Error() error { 9650 return it.fail 9651 } 9652 9653 // Close terminates the iteration process, releasing any pending underlying 9654 // resources. 9655 func (it *TONOwnershipTransferredIterator) Close() error { 9656 it.sub.Unsubscribe() 9657 return nil 9658 } 9659 9660 // TONOwnershipTransferred represents a OwnershipTransferred event raised by the TON contract. 9661 type TONOwnershipTransferred struct { 9662 PreviousOwner common.Address 9663 NewOwner common.Address 9664 Raw types.Log // Blockchain specific contextual infos 9665 } 9666 9667 // FilterOwnershipTransferred is a free log retrieval operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 9668 // 9669 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 9670 func (_TON *TONFilterer) FilterOwnershipTransferred(opts *bind.FilterOpts, previousOwner []common.Address, newOwner []common.Address) (*TONOwnershipTransferredIterator, error) { 9671 9672 var previousOwnerRule []interface{} 9673 for _, previousOwnerItem := range previousOwner { 9674 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 9675 } 9676 var newOwnerRule []interface{} 9677 for _, newOwnerItem := range newOwner { 9678 newOwnerRule = append(newOwnerRule, newOwnerItem) 9679 } 9680 9681 logs, sub, err := _TON.contract.FilterLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 9682 if err != nil { 9683 return nil, err 9684 } 9685 return &TONOwnershipTransferredIterator{contract: _TON.contract, event: "OwnershipTransferred", logs: logs, sub: sub}, nil 9686 } 9687 9688 // WatchOwnershipTransferred is a free log subscription operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 9689 // 9690 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 9691 func (_TON *TONFilterer) WatchOwnershipTransferred(opts *bind.WatchOpts, sink chan<- *TONOwnershipTransferred, previousOwner []common.Address, newOwner []common.Address) (event.Subscription, error) { 9692 9693 var previousOwnerRule []interface{} 9694 for _, previousOwnerItem := range previousOwner { 9695 previousOwnerRule = append(previousOwnerRule, previousOwnerItem) 9696 } 9697 var newOwnerRule []interface{} 9698 for _, newOwnerItem := range newOwner { 9699 newOwnerRule = append(newOwnerRule, newOwnerItem) 9700 } 9701 9702 logs, sub, err := _TON.contract.WatchLogs(opts, "OwnershipTransferred", previousOwnerRule, newOwnerRule) 9703 if err != nil { 9704 return nil, err 9705 } 9706 return event.NewSubscription(func(quit <-chan struct{}) error { 9707 defer sub.Unsubscribe() 9708 for { 9709 select { 9710 case log := <-logs: 9711 // New log arrived, parse the event and forward to the user 9712 event := new(TONOwnershipTransferred) 9713 if err := _TON.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 9714 return err 9715 } 9716 event.Raw = log 9717 9718 select { 9719 case sink <- event: 9720 case err := <-sub.Err(): 9721 return err 9722 case <-quit: 9723 return nil 9724 } 9725 case err := <-sub.Err(): 9726 return err 9727 case <-quit: 9728 return nil 9729 } 9730 } 9731 }), nil 9732 } 9733 9734 // ParseOwnershipTransferred is a log parse operation binding the contract event 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0. 9735 // 9736 // Solidity: event OwnershipTransferred(address indexed previousOwner, address indexed newOwner) 9737 func (_TON *TONFilterer) ParseOwnershipTransferred(log types.Log) (*TONOwnershipTransferred, error) { 9738 event := new(TONOwnershipTransferred) 9739 if err := _TON.contract.UnpackLog(event, "OwnershipTransferred", log); err != nil { 9740 return nil, err 9741 } 9742 return event, nil 9743 } 9744 9745 // TONTransferIterator is returned from FilterTransfer and is used to iterate over the raw logs and unpacked data for Transfer events raised by the TON contract. 9746 type TONTransferIterator struct { 9747 Event *TONTransfer // Event containing the contract specifics and raw log 9748 9749 contract *bind.BoundContract // Generic contract to use for unpacking event data 9750 event string // Event name to use for unpacking event data 9751 9752 logs chan types.Log // Log channel receiving the found contract events 9753 sub ethereum.Subscription // Subscription for errors, completion and termination 9754 done bool // Whether the subscription completed delivering logs 9755 fail error // Occurred error to stop iteration 9756 } 9757 9758 // Next advances the iterator to the subsequent event, returning whether there 9759 // are any more events found. In case of a retrieval or parsing error, false is 9760 // returned and Error() can be queried for the exact failure. 9761 func (it *TONTransferIterator) Next() bool { 9762 // If the iterator failed, stop iterating 9763 if it.fail != nil { 9764 return false 9765 } 9766 // If the iterator completed, deliver directly whatever's available 9767 if it.done { 9768 select { 9769 case log := <-it.logs: 9770 it.Event = new(TONTransfer) 9771 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 9772 it.fail = err 9773 return false 9774 } 9775 it.Event.Raw = log 9776 return true 9777 9778 default: 9779 return false 9780 } 9781 } 9782 // Iterator still in progress, wait for either a data or an error event 9783 select { 9784 case log := <-it.logs: 9785 it.Event = new(TONTransfer) 9786 if err := it.contract.UnpackLog(it.Event, it.event, log); err != nil { 9787 it.fail = err 9788 return false 9789 } 9790 it.Event.Raw = log 9791 return true 9792 9793 case err := <-it.sub.Err(): 9794 it.done = true 9795 it.fail = err 9796 return it.Next() 9797 } 9798 } 9799 9800 // Error returns any retrieval or parsing error occurred during filtering. 9801 func (it *TONTransferIterator) Error() error { 9802 return it.fail 9803 } 9804 9805 // Close terminates the iteration process, releasing any pending underlying 9806 // resources. 9807 func (it *TONTransferIterator) Close() error { 9808 it.sub.Unsubscribe() 9809 return nil 9810 } 9811 9812 // TONTransfer represents a Transfer event raised by the TON contract. 9813 type TONTransfer struct { 9814 From common.Address 9815 To common.Address 9816 Value *big.Int 9817 Raw types.Log // Blockchain specific contextual infos 9818 } 9819 9820 // FilterTransfer is a free log retrieval operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 9821 // 9822 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 9823 func (_TON *TONFilterer) FilterTransfer(opts *bind.FilterOpts, from []common.Address, to []common.Address) (*TONTransferIterator, error) { 9824 9825 var fromRule []interface{} 9826 for _, fromItem := range from { 9827 fromRule = append(fromRule, fromItem) 9828 } 9829 var toRule []interface{} 9830 for _, toItem := range to { 9831 toRule = append(toRule, toItem) 9832 } 9833 9834 logs, sub, err := _TON.contract.FilterLogs(opts, "Transfer", fromRule, toRule) 9835 if err != nil { 9836 return nil, err 9837 } 9838 return &TONTransferIterator{contract: _TON.contract, event: "Transfer", logs: logs, sub: sub}, nil 9839 } 9840 9841 // WatchTransfer is a free log subscription operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 9842 // 9843 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 9844 func (_TON *TONFilterer) WatchTransfer(opts *bind.WatchOpts, sink chan<- *TONTransfer, from []common.Address, to []common.Address) (event.Subscription, error) { 9845 9846 var fromRule []interface{} 9847 for _, fromItem := range from { 9848 fromRule = append(fromRule, fromItem) 9849 } 9850 var toRule []interface{} 9851 for _, toItem := range to { 9852 toRule = append(toRule, toItem) 9853 } 9854 9855 logs, sub, err := _TON.contract.WatchLogs(opts, "Transfer", fromRule, toRule) 9856 if err != nil { 9857 return nil, err 9858 } 9859 return event.NewSubscription(func(quit <-chan struct{}) error { 9860 defer sub.Unsubscribe() 9861 for { 9862 select { 9863 case log := <-logs: 9864 // New log arrived, parse the event and forward to the user 9865 event := new(TONTransfer) 9866 if err := _TON.contract.UnpackLog(event, "Transfer", log); err != nil { 9867 return err 9868 } 9869 event.Raw = log 9870 9871 select { 9872 case sink <- event: 9873 case err := <-sub.Err(): 9874 return err 9875 case <-quit: 9876 return nil 9877 } 9878 case err := <-sub.Err(): 9879 return err 9880 case <-quit: 9881 return nil 9882 } 9883 } 9884 }), nil 9885 } 9886 9887 // ParseTransfer is a log parse operation binding the contract event 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef. 9888 // 9889 // Solidity: event Transfer(address indexed from, address indexed to, uint256 value) 9890 func (_TON *TONFilterer) ParseTransfer(log types.Log) (*TONTransfer, error) { 9891 event := new(TONTransfer) 9892 if err := _TON.contract.UnpackLog(event, "Transfer", log); err != nil { 9893 return nil, err 9894 } 9895 return event, nil 9896 }